import { useMemo, useState } from "react";
import { Link } from "react-router-dom";
import { usePlatformModuleInstalled } from "@govoplan/core-webui";
import type { ApiSettings } from "../../types";
import { Button } from "@govoplan/core-webui";
import { Card } from "@govoplan/core-webui";
import { PageTitle } from "@govoplan/core-webui";
import { LoadingFrame } from "@govoplan/core-webui";
import LockedVersionNotice from "./components/LockedVersionNotice";
import VersionLine from "./components/VersionLine";
import { useCampaignWorkspaceData } from "./hooks/useCampaignWorkspaceData";
import { useCampaignDraftEditor } from "./hooks/useCampaignDraftEditor";
import { asArray, asRecord, isAuditLockedVersion } from "./utils/campaignView";
import FieldValueInput from "./components/FieldValueInput";
import AttachmentRulesOverlay from "./components/AttachmentRulesOverlay";
import { getDraftFields } from "./utils/fieldDefinitions";
import { getIndividualAttachmentBasePaths, normalizeAttachmentBasePaths, normalizeAttachmentRules, normalizeAttachmentZipCollection, type AttachmentBasePath, type AttachmentRule, type AttachmentZipCollection } from "./utils/attachments";
import { importedRowsNeedAttachmentSource, materializeRecipientImport, type RecipientImportMode, type RecipientImportPreview } from "./utils/bulkImport";
import { buildTemplatePreviewContext } from "./utils/templatePlaceholders";
import { RecipientImportDialog } from "./RecipientDataPage";
import { addressesFromValue } from "@govoplan/core-webui";
import { DismissibleAlert } from "@govoplan/core-webui";
import DataGrid, { type DataGridColumn } from "../../components/table/DataGrid";


export default function RecipientDetailsPage({ settings, campaignId }: { settings: ApiSettings; campaignId: string }) {
  const filesModuleInstalled = usePlatformModuleInstalled("files");
  const { data, loading, error, reload, setError } = useCampaignWorkspaceData(settings, campaignId);
  const [importOpen, setImportOpen] = useState(false);
  const [recipientDataPage, setRecipientDataPage] = useState(1);
  const [recipientDataPageSize, setRecipientDataPageSize] = useState(10);

  const version = data.currentVersion;
  const locked = isAuditLockedVersion(version, data.campaign?.current_version_id);
  const { draft, setDraft, displayDraft, dirty, saveState, localError, patch, markDirty, saveDraft } = useCampaignDraftEditor({
    settings,
    campaignId,
    version,
    locked,
    reload,
    setError,
    currentStep: "recipient-data",
    unsavedTitle: "Unsaved recipient data changes",
    unsavedMessage: "Recipient field values or attachments have unsaved changes. Save them before leaving, or discard them and continue."
  });
  const entries = asRecord(displayDraft.entries);
  const inlineEntries = asArray(entries.inline).map(asRecord);
  const source = asRecord(entries.source);
  const fieldDefinitions = useMemo(() => getDraftFields(displayDraft), [displayDraft]);
  const attachmentSection = asRecord(displayDraft.attachments);
  const attachmentBasePaths = useMemo(() => normalizeAttachmentBasePaths(attachmentSection.base_paths, attachmentSection), [attachmentSection]);
  const individualAttachmentBasePaths = useMemo(() => getIndividualAttachmentBasePaths(attachmentBasePaths), [attachmentBasePaths]);
  const importBasePaths = useMemo(() => normalizeAttachmentBasePaths(attachmentSection.base_paths, attachmentSection, true), [attachmentSection]);
  const defaultImportBasePath = useMemo(() => importBasePaths.find((basePath) => basePath.allow_individual) ?? importBasePaths[0] ?? null, [importBasePaths]);
  const zipConfig = useMemo(() => normalizeAttachmentZipCollection(attachmentSection.zip), [attachmentSection.zip]);


  function replaceInlineEntries(nextEntries: Record<string, unknown>[]) {
    patch(["entries", "inline"], nextEntries);
  }

  function updateEntry(index: number, updater: (entry: Record<string, unknown>) => Record<string, unknown>) {
    const nextEntries = inlineEntries.map((entry, currentIndex) => currentIndex === index ? updater(entry) : entry);
    replaceInlineEntries(nextEntries);
  }

  function updateEntryField(index: number, field: string, value: unknown) {
    updateEntry(index, (entry) => ({
      ...entry,
      fields: {
        ...asRecord(entry.fields),
        [field]: value
      }
    }));
  }

  function updateEntryAttachments(index: number, attachments: AttachmentRule[]) {
    updateEntry(index, (entry) => ({ ...entry, attachments }));
  }

  function applyRecipientImport(preview: RecipientImportPreview, mode: RecipientImportMode) {
    if (locked || !draft) return;
    const needsAttachmentSource = importedRowsNeedAttachmentSource(preview);
    const currentAttachments = asRecord(draft.attachments);
    let nextBasePaths = normalizeAttachmentBasePaths(currentAttachments.base_paths, currentAttachments, true);
    let attachmentBasePath: AttachmentBasePath | null = null;

    if (needsAttachmentSource) {
      if (nextBasePaths.length === 0) {
        nextBasePaths = [{ id: "base-path-campaign", name: "Campaign files", path: ".", allow_individual: true, unsent_warning: false }];
      }
      const selectedIndex = Math.max(0, nextBasePaths.findIndex((basePath) => basePath.allow_individual));
      nextBasePaths = nextBasePaths.map((basePath, index) => index === selectedIndex ? { ...basePath, allow_individual: true } : basePath);
      attachmentBasePath = nextBasePaths[selectedIndex] ?? null;
    }

    const importedDraft = materializeRecipientImport(draft, preview, { mode, attachmentBasePath });
    const nextDraft = needsAttachmentSource
      ? {
        ...importedDraft,
        attachments: {
          ...asRecord(importedDraft.attachments),
          base_paths: nextBasePaths,
          base_path: nextBasePaths[0]?.path || "."
        }
      }
      : importedDraft;
    setDraft(nextDraft);
    markDirty();
    setImportOpen(false);
  }


  return (
    <div className="content-pad workspace-data-page">
      <div className="page-heading split workspace-heading">
        <div>
          <PageTitle loading={loading}>Recipient data</PageTitle>
          <VersionLine version={version} versions={data.versions} status={saveState} />
        </div>
        <div className="button-row compact-actions">
          <Button onClick={reload} disabled={loading}>Reload</Button>
          <Button variant="primary" onClick={() => saveDraft("manual")} disabled={!dirty || locked || !draft}>Save</Button>
        </div>
      </div>

      {error && <DismissibleAlert tone="danger" resetKey={error} floating>{error}</DismissibleAlert>}
      {localError && <DismissibleAlert tone="danger" resetKey={localError} floating>{localError}</DismissibleAlert>}
      {locked && <LockedVersionNotice settings={settings} campaignId={campaignId} version={version} currentVersionId={data.campaign?.current_version_id} reload={reload} message="This page is read-only for the selected version." />}

      <LoadingFrame loading={loading || !draft} label="Loading campaign draft…">
        <>
          <Card title="Recipient field values and attachments" actions={<Button disabled={locked} onClick={() => setImportOpen(true)}>Import</Button>}>
            {inlineEntries.length === 0 && !source.type && <p className="muted">No recipient profiles are stored in the current version yet. Add recipients first, then maintain their data here.</p>}
            {inlineEntries.length === 0 && Boolean(source.type) && (
              <DismissibleAlert tone="info">This campaign references an external recipient source. A parsed data preview will be added when file/source preview support is implemented.</DismissibleAlert>
            )}
            {inlineEntries.length > 0 && (
              <div className="admin-table-surface recipient-data-table-surface">
                <DataGrid
                  id={`campaign-${campaignId}-recipient-data`}
                  rows={inlineEntries}
                  columns={recipientDataColumns({ settings, campaignId, draft: displayDraft, locked, filesModuleInstalled, fieldDefinitions, individualAttachmentBasePaths, zipConfig, updateEntryAttachments, updateEntryField })}
                  getRowKey={(entry, index) => String(entry.id || index)}
                  emptyText="No recipient data found."
                  className="recipient-table-wrap recipient-data-table-wrap recipient-data-table"
                  pagination={{
                    page: recipientDataPage,
                    pageSize: recipientDataPageSize,
                    pageSizeOptions: [10, 25, 50, 100, 250],
                    onPageChange: setRecipientDataPage,
                    onPageSizeChange: (pageSize) => {
                      setRecipientDataPageSize(pageSize);
                      setRecipientDataPage(1);
                    }
                  }}
                />
              </div>
            )}
          </Card>
        </>
      </LoadingFrame>

      {importOpen && (
        <RecipientImportDialog
          settings={settings}
          campaignId={campaignId}
          existingEntries={inlineEntries}
          existingFields={fieldDefinitions}
          defaultAttachmentBasePath={defaultImportBasePath}
          onCancel={() => setImportOpen(false)}
          onImport={applyRecipientImport}
        />
      )}
    </div>
  );
}

type RecipientDataColumnContext = {
  settings: ApiSettings;
  campaignId: string;
  draft: Record<string, unknown>;
  locked: boolean;
  filesModuleInstalled: boolean;
  fieldDefinitions: ReturnType<typeof getDraftFields>;
  individualAttachmentBasePaths: ReturnType<typeof getIndividualAttachmentBasePaths>;
  zipConfig: AttachmentZipCollection;
  updateEntryAttachments: (index: number, attachments: AttachmentRule[]) => void;
  updateEntryField: (index: number, field: string, value: unknown) => void;
};

function recipientDataColumns({ settings, campaignId, draft, locked, filesModuleInstalled, fieldDefinitions, individualAttachmentBasePaths, zipConfig, updateEntryAttachments, updateEntryField }: RecipientDataColumnContext): DataGridColumn<Record<string, unknown>>[] {
  return [
    { id: "number", header: "#", width: 70, sortable: true, filterType: "integer", sticky: "start", render: (_entry, index) => <span className="mono-small recipient-index-cell">{index + 1}</span>, value: (_entry, index) => index + 1 },
    {
      id: "recipient",
      header: "Recipient",
      width: 260,
      resizable: true,
      sortable: true,
      filterable: true,
      sticky: "start",
      render: (entry) => (
        <Link className="recipient-data-identity" to="../recipients" title="Open recipient address profile">
          <span className="recipient-data-address">{firstRecipientEmail(entry) || "No To address"}</span>
          {extraRecipientCount(entry) > 0 && <span className="recipient-extra-bubble">+{extraRecipientCount(entry)}</span>}
        </Link>
      ),
      value: firstRecipientEmail
    },
    {
      id: "attachments",
      header: "Attachments",
      width: 180,
      filterable: true,
      render: (entry, index) => {
        const attachments = normalizeAttachmentRules(entry.attachments);
        return (
          <AttachmentRulesOverlay
            title={`Attachments for recipient ${index + 1}`}
            rules={attachments}
            settings={settings}
            campaignId={campaignId}
            disabled={locked}
            buttonLabel={`entries: ${attachments.length}`}
            basePaths={individualAttachmentBasePaths}
            zipConfig={zipConfig}
            filesModuleInstalled={filesModuleInstalled}
            previewContext={buildTemplatePreviewContext(draft, entry)}
            onChange={(rules) => updateEntryAttachments(index, rules)}
          />
        );
      },
      value: (entry) => normalizeAttachmentRules(entry.attachments).map((rule) => `${rule.label ?? ""} ${rule.file_filter ?? ""}`).join(", ")
    },
    ...fieldDefinitions.map((field): DataGridColumn<Record<string, unknown>> => ({
      id: `field-${field.name}`,
      header: field.label || field.name,
      width: 190,
      resizable: true,
      sortable: true,
      filterable: true,
      filterType: field.type === "integer" ? "integer" : field.type === "double" ? "number" : field.type === "date" ? "date" : "text",
      render: (entry, index) => {
        const fields = asRecord(entry.fields);
        return (
          <FieldValueInput
            className="recipient-field-input"
            fieldType={field.type}
            value={fields[field.name]}
            disabled={locked || field.can_override === false}
            placeholder={field.can_override === false ? "Uses global value" : undefined}
            onChange={(value) => updateEntryField(index, field.name, value)}
          />
        );
      },
      value: (entry) => String(asRecord(entry.fields)[field.name] ?? "")
    }))
  ];
}

function firstRecipientEmail(entry: Record<string, unknown>): string {
  return (addressesFromValue(entry.to)[0] ?? addressesFromValue(entry.recipient)[0] ?? addressesFromValue(entry)[0])?.email ?? "";
}

function extraRecipientCount(entry: Record<string, unknown>): number {
  const count = addressesFromValue(entry.to).length;
  return Math.max(0, count - 1);
}