import { PureComponent } from 'react';
import Box from '@mui/material/Box';
import CircularProgress from '@mui/material/CircularProgress';
import { enqueueSnackbar } from 'notistack';
import BackendError from '../BackendError';
import { PanelTileGrid } from 'dashgui/panels';
import { delivery as deliveryApi } from '../../api';
import { requireArray, requireDefined, requireObject } from '../../utils/apiShape';
import { backendErrorFrom } from '../../utils/backendError';
import { notifyError } from '../../utils/notify';
import withNavigate from '../withNavigate';
import ManifestHeader from './ManifestHeader';
import ManifestLines from './ManifestLines';
import ManifestPdfDialog from './ManifestPdfDialog';
import ArticleSearchDialog from './ArticleSearchDialog';
import artikelAutomat, { getArticle } from '../../automats/artikelAutomat';
import { netFromGross, getArticleGross } from '../../utils/price';
import {
  buildManifestBody,
  restoreAttachmentsFromApi,
  dateInputValue,
  emptyLine,
  lineFromApi,
  loadParties,
  manifestConfig,
  apiFor,
  parseNum,
} from './manifestConfig';

class ManifestForm extends PureComponent {
  constructor(props) {
    super(props);
    this.cfg = manifestConfig(props.kind);
    this.state = {
      status: props.mode === 'edit' ? 'loading' : 'loadingParties',
      error: null,
      parties: [],
      partiesLoading: true,
      date: '',
      partyId: null,
      number: '',
      externalNumber: '',
      lines: [emptyLine()],
      attachments: [],
      saving: false,
      pdfUploading: false,
      pdfDialogOpen: false,
      pdfDialogData: null,
      pdfFileName: '',
      articleSearchDialogOpen: false,
      articleSearchLine: null,
    };
    this._cancelled = false;
    this.handleRetry = this.handleRetry.bind(this);
    this.handlePartyChange = this.handlePartyChange.bind(this);
    this.handleDateChange = this.handleDateChange.bind(this);
    this.handleNumberChange = this.handleNumberChange.bind(this);
    this.handleExternalNumberChange =
      this.handleExternalNumberChange.bind(this);
    this.handleLineChange = this.handleLineChange.bind(this);
    this.handleSkuBlur = this.handleSkuBlur.bind(this);
    this.handleAddLine = this.handleAddLine.bind(this);
    this.handleAddArticleLine = this.handleAddArticleLine.bind(this);
    this.handleOpenArticleSearchForLine = this.handleOpenArticleSearchForLine.bind(this);
    this.handleCloseArticleSearch = this.handleCloseArticleSearch.bind(this);
    this.handleAssignArticleForLine = this.handleAssignArticleForLine.bind(this);
    this.handleRemoveLine = this.handleRemoveLine.bind(this);
    this.handleRemoveAllLines = this.handleRemoveAllLines.bind(this);
    this.handleSave = this.handleSave.bind(this);
    this.handlePdfUpload = this.handlePdfUpload.bind(this);
    this.handleClosePdfDialog = this.handleClosePdfDialog.bind(this);
    this.handleAbortParse = this.handleAbortParse.bind(this);
  }

  componentDidMount() {
    this._cancelled = false;
    if (this.props.mode === 'edit') void this.loadEdit();
    else void this.loadPartiesOnly();
  }

  componentDidUpdate(prevProps) {
    if (
      this.props.mode === 'edit' &&
      prevProps.docId !== this.props.docId
    ) {
      void this.loadEdit();
    }
  }

  componentWillUnmount() {
    this._cancelled = true;
    if (this._parseAbortController) {
      this._parseAbortController.abort();
      this._parseAbortController = null;
    }
  }

  async loadPartiesOnly() {
    this.setState({ status: 'loadingParties', error: null, partiesLoading: true });
    try {
      const parties = await loadParties(this.props.kind);
      if (this._cancelled) return;
      this.setState({
        status: 'ready',
        parties,
        partiesLoading: false,
      });
    } catch (err) {
      if (this._cancelled) return;
      this.setState({
        status: 'failed',
        error: backendErrorFrom(err),
        partiesLoading: false,
      });
      notifyError(err);
    }
  }

  async loadEdit() {
    const { docId, kind } = this.props;
    const cfg = this.cfg;
    if (docId == null) {
      this.setState({
        status: 'failed',
        error: backendErrorFrom(new Error(cfg.invalidId)),
      });
      return;
    }

    this.setState({ status: 'loading', error: null, partiesLoading: true });
    try {
      const [docRes, parties] = await Promise.all([
        apiFor(cfg).get(docId),
        loadParties(kind),
      ]);
      if (this._cancelled) return;

      requireObject(docRes, cfg.getPathLabel);
      requireObject(docRes[cfg.docField], cfg.docField);
      const doc = docRes[cfg.docField];
      const apiLines = requireArray(doc.lines, `${cfg.docField}.lines`);
      const lines =
        apiLines.length > 0 ? apiLines.map(lineFromApi) : [emptyLine()];

      // Restore attachments if available
      const apiFiles = doc.files ?? [];
      const attachments = await restoreAttachmentsFromApi(apiFiles);

      this.setState({
        status: 'ready',
        parties,
        partiesLoading: false,
        date: dateInputValue(doc.date),
        partyId: doc[cfg.partyField],
        number: doc.number ?? '',
        externalNumber:
          doc.externalNumber != null ? String(doc.externalNumber) : '',
        lines,
        attachments,
      });
    } catch (err) {
      if (this._cancelled) return;
      this.setState({
        status: 'failed',
        error: backendErrorFrom(err),
        partiesLoading: false,
      });
    }
  }

  handleRetry() {
    if (this.props.mode === 'edit') void this.loadEdit();
    else void this.loadPartiesOnly();
  }

  handlePartyChange(partyId) {
    const { mode } = this.props;
    const { requirePartyBeforeLines } = this.cfg;
    if (mode === 'create' && requirePartyBeforeLines && partyId == null) {
      this.setState({ partyId: null, lines: [emptyLine()] });
      return;
    }
    this.setState({ partyId });
  }

  handleDateChange(date) {
    this.setState({ date });
  }

  handleNumberChange(number) {
    this.setState({ number });
  }

  handleExternalNumberChange(externalNumber) {
    this.setState({ externalNumber });
  }

  handleLineChange(key, field, value) {
    this.setState((prev) => ({
      lines: prev.lines.map((line) => {
        if (line.key !== key) return line;

        if (field === 'gross') {
          const taxVal = parseNum(line.tax ?? line.taxrate) ?? 0;
          const grossNum = parseNum(value);
          let updatedNet = line.net;
          if (grossNum != null) {
            const netNum = netFromGross(grossNum, taxVal);
            if (netNum != null) {
              updatedNet = String(netNum);
            }
          } else if (value === '') {
            updatedNet = '';
          }
          return {
            ...line,
            gross: value,
            net: updatedNet,
            netprice: updatedNet,
          };
        }

        if (field === 'net' || field === 'netprice') {
          const taxVal = parseNum(line.tax ?? line.taxrate) ?? 0;
          const netNum = parseNum(value);
          let updatedGross = line.gross;
          if (netNum != null) {
            const grossNum = Math.round((netNum * (1 + taxVal / 100) + Number.EPSILON) * 100) / 100;
            updatedGross = String(grossNum);
          } else if (value === '') {
            updatedGross = '';
          }
          return {
            ...line,
            [field]: value,
            net: value,
            netprice: value,
            gross: updatedGross,
          };
        }

        if (field === 'tax' || field === 'taxrate') {
          const taxNum = parseNum(value) ?? 0;
          const netNum = parseNum(line.net ?? line.netprice);
          let updatedGross = line.gross;
          if (netNum != null) {
            const grossNum = Math.round((netNum * (1 + taxNum / 100) + Number.EPSILON) * 100) / 100;
            updatedGross = String(grossNum);
          }
          return {
            ...line,
            [field]: value,
            tax: value,
            taxrate: value,
            gross: updatedGross,
          };
        }

        return {
          ...line,
          [field]: value,
        };
      }),
    }));
  }

  async handleSkuBlur(key, sku) {
    const trimmed = String(sku ?? '').trim();
    if (!trimmed) return;
    try {
      const art = getArticle(trimmed) || (await artikelAutomat.actions.loadArticle(trimmed));
      if (art && !this._cancelled) {
        this.setState((prev) => ({
          lines: prev.lines.map((l) => {
            if (l.key !== key) return l;
            const netVal =
              art.price != null
                ? String(art.price)
                : art.vknetto != null
                  ? String(art.vknetto)
                  : art.net != null
                    ? String(art.net)
                    : '';
            const taxVal =
              art.taxrate != null
                ? String(art.taxrate)
                : art.tax != null
                  ? String(art.tax)
                  : '';
            const netNum = parseNum(netVal);
            const taxNum = parseNum(taxVal);
            const artGross = getArticleGross(art, taxNum ?? 0);
            let grossVal = '';
            if (artGross != null) {
              grossVal = String(artGross);
            } else if (netNum != null) {
              const g = Math.round((netNum * (1 + (taxNum ?? 0) / 100) + Number.EPSILON) * 100) / 100;
              grossVal = String(g);
            }
            return {
              ...l,
              sku: art.sku || l.sku,
              name: art.name || l.name || '',
              tax: l.tax || taxVal,
              taxrate: l.taxrate || taxVal,
              net: l.net || netVal,
              netprice: l.netprice || netVal,
              gross: l.gross || grossVal,
              unit: art.unit || l.unit || 'Stück',
            };
          }),
        }));
      }
    } catch {
      // not in catalog or load error; preserve user entry
    }
  }

  handleAddLine() {
    this.setState((prev) => ({ lines: [...prev.lines, emptyLine()] }));
  }

  handleAddArticleLine(article) {
    if (!article) return;
    const netVal =
      article.price != null
        ? String(article.price)
        : article.vknetto != null
          ? String(article.vknetto)
          : article.net != null
            ? String(article.net)
            : '';
    const taxVal =
      article.taxrate != null
        ? String(article.taxrate)
        : article.tax != null
          ? String(article.tax)
          : '';
    const netNum = parseNum(netVal);
    const taxNum = parseNum(taxVal);
    const artGross = getArticleGross(article, taxNum ?? 0);
    let grossVal = '';
    if (artGross != null) {
      grossVal = String(artGross);
    } else if (netNum != null) {
      const g = Math.round((netNum * (1 + (taxNum ?? 0) / 100) + Number.EPSILON) * 100) / 100;
      grossVal = String(g);
    }

    const newLine = {
      key: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
      amount: '1',
      sku: article.sku || '',
      name: article.name || '',
      tax: taxVal,
      taxrate: taxVal,
      net: netVal,
      netprice: netVal,
      gross: grossVal,
      rebate: '',
      pu: '1',
      unit: article.unit || 'Stück',
    };

    this.setState((prev) => {
      if (prev.lines.length === 1 && !prev.lines[0].sku && !prev.lines[0].name) {
        return { lines: [newLine] };
      }
      return { lines: [...prev.lines, newLine] };
    });
  }

  handleOpenArticleSearchForLine(line) {
    this.setState({
      articleSearchDialogOpen: true,
      articleSearchLine: line,
    });
  }

  handleCloseArticleSearch() {
    this.setState({
      articleSearchDialogOpen: false,
      articleSearchLine: null,
    });
  }

  handleAssignArticleForLine(article, targetLine) {
    if (!article) return;
    if (!targetLine) {
      this.handleAddArticleLine(article);
      this.setState({
        articleSearchDialogOpen: false,
        articleSearchLine: null,
      });
      return;
    }
    const netVal =
      article.price != null
        ? String(article.price)
        : article.vknetto != null
          ? String(article.vknetto)
          : article.net != null
            ? String(article.net)
            : '';
    const taxVal =
      article.taxrate != null
        ? String(article.taxrate)
        : article.tax != null
          ? String(article.tax)
          : '';
    const netNum = parseNum(netVal);
    const taxNum = parseNum(taxVal);
    const artGross = getArticleGross(article, taxNum ?? 0);
    let grossVal = '';
    if (artGross != null) {
      grossVal = String(artGross);
    } else if (netNum != null) {
      const g = Math.round((netNum * (1 + (taxNum ?? 0) / 100) + Number.EPSILON) * 100) / 100;
      grossVal = String(g);
    }

    this.setState((prev) => ({
      lines: prev.lines.map((l) => {
        if (l.key !== targetLine.key) return l;
        return {
          ...l,
          sku: article.sku || l.sku,
          name: article.name || l.name,
          tax: taxVal || l.tax,
          taxrate: taxVal || l.taxrate,
          net: netVal || l.net,
          netprice: netVal || l.netprice,
          gross: grossVal || l.gross,
          unit: article.unit || l.unit || 'Stück',
        };
      }),
      articleSearchDialogOpen: false,
      articleSearchLine: null,
    }));
  }

  handleRemoveLine(key) {
    this.setState((prev) => {
      const next = prev.lines.filter((line) => line.key !== key);
      return { lines: next.length > 0 ? next : [emptyLine()] };
    });
  }

  handleRemoveAllLines() {
    this.setState({ lines: [] });
  }

  async handlePdfUpload(file) {
    if (!file || this.state.pdfUploading) return;
    if (this._parseAbortController) {
      this._parseAbortController.abort();
    }
    const abortController = new AbortController();
    this._parseAbortController = abortController;

    this.setState({
      pdfUploading: true,
      pdfDialogOpen: true,
      pdfFileName: file.name,
      pdfDialogData: { streaming: true, messages: [], result: null, error: null, aborted: false },
    });

    const appendMessage = (msg) => {
      if (this._cancelled || abortController.signal.aborted) return;
      this.setState((prev) => ({
        pdfDialogData: {
          ...prev.pdfDialogData,
          messages: [...(prev.pdfDialogData?.messages ?? []), msg],
        },
      }));
    };

    try {
      const gen = deliveryApi.parsePdfSse;
      if (!gen) throw new Error('parsePdfSse nicht verfügbar.');

      for await (const { event, data } of gen(file, { signal: abortController.signal })) {
        if (this._cancelled || abortController.signal.aborted) return;
        switch (event) {
          case 'status':
            appendMessage({ type: 'status', text: data.message ?? String(data) });
            break;
          case 'llm_call':
            appendMessage({ type: 'llm_call', text: `LLM-Aufruf: ${data.model} (${data.promptSize} tokens, ${data.messages} msg)` });
            break;
          case 'tool_call':
            appendMessage({ type: 'tool_call', text: `Tool-Aufruf: ${data.name}` });
            break;
          case 'usage':
            appendMessage({ type: 'usage', text: `Token-Verbrauch: ${data.input} in / ${data.cached} cached / ${data.output} out — $${(data.cost ?? 0).toFixed(4)}` });
            break;
          case 'progress':
            this.setState((prev) => ({
              pdfDialogData: { ...prev.pdfDialogData, result: data },
            }));
            break;
          case 'result':
            this.setState((prev) => ({
              pdfDialogData: { ...prev.pdfDialogData, result: data, streaming: false },
            }));
            break;
          case 'error':
            this.setState((prev) => ({
              pdfDialogData: { ...prev.pdfDialogData, error: data.message ?? String(data), streaming: false },
            }));
            return;
          default:
            break;
        }
      }
    } catch (err) {
      if (this._cancelled) return;
      if (abortController.signal.aborted || err.name === 'AbortError') {
        this.setState((prev) => ({
          pdfDialogData: {
            ...prev.pdfDialogData,
            streaming: false,
            aborted: true,
            error: 'Analyse abgebrochen.',
          },
        }));
        return;
      }
      notifyError(err);
      this.setState((prev) => ({
        pdfDialogData: {
          ...(prev.pdfDialogData ?? {}),
          error: err.message || String(err),
          streaming: false,
        },
      }));
    } finally {
      if (this._parseAbortController === abortController) {
        this._parseAbortController = null;
      }
      if (!this._cancelled) {
        this.setState((prev) => ({
          pdfUploading: false,
          pdfDialogData: prev.pdfDialogData
            ? { ...prev.pdfDialogData, streaming: false }
            : null,
        }));
      }
    }
  }

  handleAbortParse() {
    if (this._parseAbortController) {
      this._parseAbortController.abort();
      this._parseAbortController = null;
    }
    this.setState((prev) => ({
      pdfUploading: false,
      pdfDialogData: prev.pdfDialogData
        ? {
            ...prev.pdfDialogData,
            streaming: false,
            aborted: true,
            error: 'Analyse abgebrochen.',
          }
        : null,
    }));
  }

  handleClosePdfDialog() {
    if (this._parseAbortController) {
      this._parseAbortController.abort();
      this._parseAbortController = null;
    }
    this.setState({ pdfDialogOpen: false, pdfUploading: false });
  }

  async handleSave() {
    const { mode, docId } = this.props;
    const cfg = this.cfg;
    if (this.state.saving) return;
    if (mode === 'edit' && docId == null) return;

    const requireAtLeastOne = mode === 'create';
    let body;
    try {
      body = await buildManifestBody(
        {
          number: this.state.number,
          externalNumber: this.state.externalNumber,
          date: this.state.date,
          partyId: this.state.partyId,
          lines: this.state.lines,
          attachments: this.state.attachments,
        },
        {
          partyField: cfg.partyField,
          requireAtLeastOne,
          externalNumber: cfg.externalNumber,
        },
      );
    } catch (err) {
      notifyError(err);
      return;
    }

    this.setState({ saving: true });
    const api = apiFor(cfg);
    try {
      if (mode === 'create') {
        const data = await api.create(body);
        requireObject(data, cfg.postPathLabel);
        requireObject(data[cfg.docField], cfg.docField);
        requireDefined(data[cfg.docField].id, `${cfg.docField}.id`);
        await cfg.listAutomat.actions.reload();
        if (this._cancelled) return;
        enqueueSnackbar(cfg.createdMsg, { variant: 'success' });
        this.props.navigate(cfg.editPath(data[cfg.docField].id));
        return;
      }

      const data = await api.update(docId, body);
      requireObject(data, cfg.patchPathLabel);
      requireObject(data[cfg.docField], cfg.docField);
      requireDefined(data[cfg.docField].id, `${cfg.docField}.id`);
      await cfg.listAutomat.actions.reload();
      if (this._cancelled) return;
      const doc = data[cfg.docField];
      const apiLines = requireArray(doc.lines, `${cfg.docField}.lines`);
      this.setState({
        date: dateInputValue(doc.date),
        partyId: doc[cfg.partyField],
        number: doc.number ?? '',
        externalNumber:
          doc.externalNumber != null ? String(doc.externalNumber) : '',
        lines:
          apiLines.length > 0 ? apiLines.map(lineFromApi) : [emptyLine()],
        saving: false,
      });
      enqueueSnackbar(cfg.savedMsg, { variant: 'success' });
    } catch (err) {
      if (this._cancelled) return;
      notifyError(err);
      this.setState({ saving: false });
    }
  }

  renderArticles() {
    const cfg = this.cfg;
    const { lines, saving } = this.state;

    return (
      <ManifestLines
        kind={cfg.kind}
        columns={cfg.columns}
        lines={lines}
        saving={saving}
        wide={4}
        linesColor={cfg.linesColor}
        onLineChange={this.handleLineChange}
        onSkuBlur={this.handleSkuBlur}
        onAddLine={this.handleAddLine}
        onAddArticleLine={this.handleAddArticleLine}
        onSearchArticle={this.handleOpenArticleSearchForLine}
        onRemoveLine={this.handleRemoveLine}
        onRemoveAllLines={this.handleRemoveAllLines}
        onSave={() => void this.handleSave()}
      />
    );
  }

  render() {
    const { kind } = this.props;
    const cfg = this.cfg;
    const {
      status,
      error,
      parties,
      partiesLoading,
      date,
      partyId,
      number,
      externalNumber,
      lines,
      saving,
      pdfUploading,
      pdfDialogOpen,
      pdfDialogData,
      pdfFileName,
    } = this.state;

    if (status === 'loading') {
      return (
        <Box sx={{ display: 'flex', justifyContent: 'center', py: 6 }}>
          <CircularProgress />
        </Box>
      );
    }

    if (status === 'failed') {
      return <BackendError error={error} onRetry={this.handleRetry} />;
    }

    return (
      <>
        <PanelTileGrid>
          <ManifestHeader
            kind={kind}
            headerColor={cfg.headerColor}
            dateLabel={cfg.dateLabel}
            partyLabel={cfg.partyLabel}
            parties={parties}
            partiesLoading={partiesLoading || status === 'loadingParties'}
            partyId={partyId}
            date={date}
            number={number}
            externalNumber={externalNumber}
            saving={saving}
            pdfUploading={pdfUploading}
            lines={lines}
            onPdfUpload={kind === 'delivery' ? this.handlePdfUpload : undefined}
            onSave={this.handleSave}
            onPartyChange={this.handlePartyChange}
            onDateChange={this.handleDateChange}
            onNumberChange={this.handleNumberChange}
            onExternalNumberChange={this.handleExternalNumberChange}
          />
          {status === 'ready' ? this.renderArticles() : null}
        </PanelTileGrid>
        <ManifestPdfDialog
          open={pdfDialogOpen}
          filename={pdfFileName}
          data={pdfDialogData}
          onClose={this.handleClosePdfDialog}
          onAbort={this.handleAbortParse}
        />
        <ArticleSearchDialog
          open={this.state.articleSearchDialogOpen}
          line={this.state.articleSearchLine}
          kind={kind}
          onClose={this.handleCloseArticleSearch}
          onAssign={this.handleAssignArticleForLine}
        />
      </>
    );
  }
}

export default withNavigate(ManifestForm);