"use client";

import { useState, useCallback, useMemo, useEffect, useRef } from "react";
import {
  Modal,
  Steps,
  Button,
  Space,
  Table,
  Select,
  Row,
  Col,
  Flex,
  Progress,
  Typography,
  Empty,
  Tag,
  Alert,
  App,
  theme,
} from "antd";
import { ReloadOutlined } from "@ant-design/icons";
import { useMutation } from "@tanstack/react-query";
import { useSubscription } from "@trpc/tanstack-react-query";
import type { BaseVersion, Config, UploadReleaseType } from "@/types";
import type { ParsedProject } from "@/services/project";
import { platforms } from "@/services/publish.schemas";
import type { PlatformResult, ProgressEvent } from "@/services/publish.schemas";
import { Template } from "@/lib/utils/template";
import type { McVersionEntry } from "@/lib/utils/mcVersion";
import { computeVersionRanges } from "@/lib/utils/mcVersion";
import { getModrinthMcVersions, getCurseForgeMcVersions } from "@/services/meta";
import { trpc } from "@/lib/trpc";
import { ChangelogEditor } from "./ChangelogEditor";

const { Text } = Typography;

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

interface PublishVersion {
  key: string;
  mc_version: string;
  artifact: string | null;
  sources: string | null;
  mrRange: string;
  cfRange: string;
  modrinthVersion: string;
  modrinthVersionName: string;
  existsModrinth: boolean;
  existsCurseforge: boolean;
}

interface PublishModalProps {
  open: boolean;
  /** 配置文件名（configs/ 下的 .json 文件名） */
  configFile: string;
  config: Config;
  project: ParsedProject;
  lastVersionEnd: string | null;
  onClose: () => void;
}

type ReleaseType = Extract<BaseVersion["version_type"], UploadReleaseType>;

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function entriesToMap(
  entries: McVersionEntry[] | null,
  field: "explicit" | "wildcard",
): Map<string, string> {
  const map = new Map<string, string>();
  if (entries) {
    for (const entry of entries) {
      map.set(entry.version, entry[field]);
    }
  }
  return map;
}

const RELEASE_TYPE_LABEL_MAP: Record<ReleaseType, string> = {
  release: "Release",
  beta: "Beta",
  alpha: "Alpha"
};
const RELEASE_TYPES = Object.entries(RELEASE_TYPE_LABEL_MAP).map(v => ({ value: v[0], label: v[1] }));

// ---------------------------------------------------------------------------
// Component
// ---------------------------------------------------------------------------

export function PublishModal({
  open,
  configFile,
  config,
  project,
  lastVersionEnd,
  onClose,
}: PublishModalProps) {
  const { token } = theme.useToken();
  const { message } = App.useApp();
  const [currentStep, setCurrentStep] = useState(0);

  // Version selection
  const [selectedModrinth, setSelectedModrinth] = useState<string[]>([]);
  const [selectedCurseforge, setSelectedCurseforge] = useState<string[]>([]);

  // Publish settings
  const [changelog, setChangelog] = useState("");
  const [versionType, setVersionType] = useState<ReleaseType>(
    "release",
  );

  // Progress & result
  const [publishing, setPublishing] = useState(false);
  const [publishDone, setPublishDone] = useState(false);
  const [progress, setProgress] = useState<
    Record<
      typeof platforms[number],
      { done: number; total: number; status: ProgressEvent["status"] }
    >
  >({
    modrinth: { done: 0, total: 0, status: "running" },
    curseforge: { done: 0, total: 0, status: "running" },
  });
  const [publishResult, setPublishResult] = useState<{
    success: number;
    failed: number;
    errors: Record<typeof platforms[number], string[]>;
  } | null>(null);

  // Platform MC versions — loaded when modal opens
  const [loadingExisting, setLoadingExisting] = useState(false);
  const [modrinthMcVersions, setModrinthMcVersions] = useState<string[]>([]);
  const [curseforgeMcVersions, setCurseforgeMcVersions] = useState<string[]>([]);
  const [existingModrinth, setExistingModrinth] = useState<string[]>([]);
  const [existingCurseforge, setExistingCurseforge] = useState<string[]>([]);

  const loadExisting = useCallback(async () => {
    setLoadingExisting(true);
    try {
      const [mrVersions, cfVersions] = await Promise.all([
        getModrinthMcVersions(),
        getCurseForgeMcVersions(),
      ]);
      setModrinthMcVersions(mrVersions);
      setCurseforgeMcVersions(cfVersions);
      // TODO: Fetch existing versions from both platforms via tRPC/Server Action
      setExistingModrinth([]);
      setExistingCurseforge([]);
    } catch (e) {
      console.error(e);
    } finally {
      setLoadingExisting(false);
    }
  }, []);

  // Auto-load MC versions when modal opens
  useEffect(() => {
    if (open) {
      loadExisting();
    }
  }, [open, loadExisting]);

  // Pre-compute version display values
  const versionTmpl = useMemo(() => new Template(config.modrinth.version), [config.modrinth.version]);
  const versionNameTmpl = useMemo(() => new Template(config.modrinth.version_name), [config.modrinth.version_name]);

  // Compute per-platform version ranges
  const projectVersions = useMemo(
    () => project.artifacts.map((a) => a.mc_version),
    [project],
  );

  const mrRanges = useMemo(() => {
    if (modrinthMcVersions.length === 0) return null;
    return computeVersionRanges(projectVersions, modrinthMcVersions, lastVersionEnd ?? undefined);
  }, [projectVersions, modrinthMcVersions, lastVersionEnd]);

  const cfRanges = useMemo(() => {
    if (curseforgeMcVersions.length === 0) return null;
    return computeVersionRanges(projectVersions, curseforgeMcVersions, lastVersionEnd ?? undefined);
  }, [projectVersions, curseforgeMcVersions, lastVersionEnd]);

  // Build per-platform range maps (mc_version → explicit)
  const mrExplicitMap = useMemo(() => entriesToMap(mrRanges, "explicit"), [mrRanges]);
  const cfExplicitMap = useMemo(() => entriesToMap(cfRanges, "explicit"), [cfRanges]);

  // Build publish version rows from project artifacts
  const publishVersions: PublishVersion[] = useMemo(() =>
    project.artifacts.map((a) => {
      // Note: version_name template uses Modrinth explicit range for ${mc_version_range}
      const mrRange = mrExplicitMap.get(a.mc_version) ?? a.mc_version;
      const tmplValues = {
        version: project.version,
        mc_version: a.mc_version,
        mc_version_range: mrRange,
      };
      return {
        key: a.mc_version,
        mc_version: a.mc_version,
        artifact: a.artifact,
        sources: a.sources,
        mrRange: mrExplicitMap.get(a.mc_version) ?? a.mc_version,
        cfRange: cfExplicitMap.get(a.mc_version) ?? a.mc_version,
        modrinthVersion: versionTmpl.format(tmplValues),
        modrinthVersionName: versionNameTmpl.format(tmplValues),
        existsModrinth: existingModrinth.includes(a.mc_version),
        existsCurseforge: existingCurseforge.includes(a.mc_version),
      };
    }),
    [project, versionTmpl, versionNameTmpl, mrExplicitMap, cfExplicitMap, existingModrinth, existingCurseforge],
  );

  // Auto-select all non-existing versions when data first loads
  const initRef = useRef(false);
  useEffect(() => {
    if (open) {
      initRef.current = false;
    }
  }, [open]);
  useEffect(() => {
    if (!loadingExisting && publishVersions.length > 0 && !initRef.current) {
      initRef.current = true;
      setSelectedModrinth(
        publishVersions.filter((v) => !v.existsModrinth).map((v) => v.key),
      );
      setSelectedCurseforge(
        publishVersions.filter((v) => !v.existsCurseforge).map((v) => v.key),
      );
    }
  }, [loadingExisting, publishVersions]);

  // --------------- Steps handling ---------------

  const handleNext = useCallback(() => {
    setCurrentStep((prev) => Math.min(prev + 1, 2));
  }, []);

  const handlePrev = useCallback(() => {
    setCurrentStep((prev) => Math.max(prev - 1, 0));
  }, []);

  const handleConfirmPublish = useCallback(() => {
    // 重置状态并进入进度页；真正发起 mutation 在下方 useSubscription 的
    // onStarted 里（保证先连上 SSE 再发布，不漏早期进度事件）
    setPublishing(true);
    setPublishDone(false);
    setPublishResult(null);
    setProgress({
      modrinth: { done: 0, total: selectedModrinth.length, status: "running" },
      curseforge: {
        done: 0,
        total: selectedCurseforge.length,
        status: "running",
      },
    });
    setCurrentStep(2);
  }, [selectedModrinth.length, selectedCurseforge.length]);

  const publishMutation = useMutation(
    trpc.publish.mutationOptions({
      onSuccess: (result) => {
        let success = 0;
        let failed = 0;
        const errors = { modrinth: [], curseforge: [] } as Record<
          typeof platforms[number],
          string[]
        >;
        for (const platform of platforms) {
          const r: PlatformResult = result[platform];
          success += r.success;
          failed += r.fail;
          errors[platform] = r.errors;
        }
        setPublishResult({ success, failed, errors });
        setPublishDone(true);
        setPublishing(false);
      },
      onError: (error) => {
        message.error(`发布请求失败：${error.message}`);
        setPublishDone(true);
        setPublishing(false);
      },
    }),
  );

  useSubscription(
    trpc.progress.subscriptionOptions(undefined, {
      enabled: publishing,
      onStarted: () => {
        // SSE 已连接，现在发起发布不会漏事件
        publishMutation.mutate({
          configFile,
          version: project.version,
          mcVersions: {
            modrinth: selectedModrinth.map((mc_version) => ({ mc_version })),
            curseforge: selectedCurseforge.map((mc_version) => ({ mc_version })),
          },
          cutoffMcVersion: lastVersionEnd ?? "",
          changelog,
          versionType,
        });
      },
      onData: (event) => {
        setProgress((prev) => ({
          ...prev,
          [event.platform]: {
            done: event.current,
            total: event.total,
            status: event.status,
          },
        }));
      },
      onError: (error) => {
        console.error("Progress subscription error:", error);
      },
    }),
  );

  const handleClose = useCallback(() => {
    if (publishing) return;
    setCurrentStep(0);
    setSelectedModrinth([]);
    setSelectedCurseforge([]);
    setChangelog("");
    setVersionType("release");
    setPublishResult(null);
    setPublishDone(false);
    onClose();
  }, [publishing, onClose]);

  // --------------- Render: Step 1 — Version Selection ---------------

  const renderStep1 = () => {
    const modrinthColumns = [
      {
        title: "版本号",
        dataIndex: "modrinthVersion",
        key: "modrinthVersion",
      },
      {
        title: "兼容范围",
        dataIndex: "mrRange",
        key: "mr_range",
        width: 100,
        render: (val: string) => <Tag>{val}</Tag>,
      },
      {
        title: "版本名称",
        dataIndex: "modrinthVersionName",
        key: "modrinthVersionName",
      },
    ];

    const curseforgeColumns = [
      {
        title: "MC 版本",
        dataIndex: "mc_version",
        key: "mc_version",
        width: 100,
      },
      {
        title: "兼容范围",
        dataIndex: "cfRange",
        key: "cf_range",
        width: 100,
        render: (val: string) => <Tag>{val}</Tag>,
      },
      {
        title: "显示名称",
        dataIndex: "artifact",
        key: "artifact",
        ellipsis: true,
      },
    ];

    return (
      <div>
        <div
          style={{
            display: "flex",
            justifyContent: "space-between",
            alignItems: "center",
            marginBottom: token.margin,
          }}
        >
          <Text strong>选择要发布的版本</Text>
          <Button
            icon={<ReloadOutlined />}
            loading={loadingExisting}
            onClick={loadExisting}
            size="small"
          >
            刷新已有版本
          </Button>
        </div>

        {loadingExisting ? (
          <div style={{ textAlign: "center", padding: 40 }}>加载中…</div>
        ) : (
          <Row gutter={token.margin}>
            <Col span={14}>
              <Text strong style={{ display: "block", marginBottom: token.marginXS }}>
                Modrinth
              </Text>
              {publishVersions.length > 0 ? (
                <Table
                  dataSource={publishVersions}
                  columns={modrinthColumns}
                  rowSelection={{
                    selectedRowKeys: selectedModrinth,
                    onChange: (keys) => setSelectedModrinth(keys as string[]),
                    getCheckboxProps: (r: PublishVersion) => ({
                      disabled: r.existsModrinth,
                    }),
                  }}
                  pagination={false}
                  size="small"
                  bordered
                />
              ) : (
                <Empty description="无版本" />
              )}
            </Col>
            <Col span={10}>
              <Text strong style={{ display: "block", marginBottom: token.marginXS }}>
                CurseForge
              </Text>
              {publishVersions.length > 0 ? (
                <Table
                  dataSource={publishVersions}
                  columns={curseforgeColumns}
                  rowSelection={{
                    selectedRowKeys: selectedCurseforge,
                    onChange: (keys) => setSelectedCurseforge(keys as string[]),
                    getCheckboxProps: (r: PublishVersion) => ({
                      disabled: r.existsCurseforge,
                    }),
                  }}
                  pagination={false}
                  size="small"
                  bordered
                />
              ) : (
                <Empty description="无版本" />
              )}
            </Col>
          </Row>
        )}
      </div>
    );
  };

  // --------------- Render: Step 2 — Publish Settings ---------------

  const renderStep2 = () => {
    return (
      <div>
        {/* Changelog */}
        <div style={{ marginBottom: token.marginLG }}>
          <Text strong style={{ display: "block", marginBottom: token.marginSM }}>
            Changelog (Markdown)
          </Text>
          <ChangelogEditor value={changelog} onChange={setChangelog} />
        </div>

        {/* Version type */}
        <div>
          <Text strong style={{ display: "block", marginBottom: token.marginSM }}>
            版本类型
          </Text>
          <Select
            value={versionType}
            onChange={(v) => setVersionType(v)}
            style={{ width: 160 }}
            options={RELEASE_TYPES}
          />
        </div>
      </div>
    );
  };

  // --------------- Render: Step 3 — Progress & Result ---------------

  const renderStep3 = () => {
    const hasModrinth = selectedModrinth.length > 0;
    const hasCurseforge = selectedCurseforge.length > 0;

    return (
      <div>
        {/* Progress bars */}
        <div style={{ marginBottom: token.marginLG }}>
          <Flex vertical gap={token.marginSM}>
            {hasModrinth && (
              <Flex align="center" gap={token.marginXS}>
                <img
                  src="/platform/modrinth.svg"
                  alt="Modrinth"
                  style={{ width: 30, height: 30, flexShrink: 0 }}
                />
                <Text style={{ width: 80, flexShrink: 0, fontFamily: "Inter", fontWeight: "bold" }}>Modrinth</Text>
                <Progress
                  percent={Math.round(
                    (progress.modrinth.done /
                      Math.max(progress.modrinth.total, 1)) *
                      100,
                  )}
                  status={
                    progress.modrinth.status === "failed"
                      ? "exception"
                      : undefined
                  }
                  format={() =>
                    `${progress.modrinth.done} / ${progress.modrinth.total}`
                  }
                  style={{ flex: 1 }}
                />
              </Flex>
            )}
            {hasCurseforge && (
              <Flex align="center" gap={token.marginXS}>
                <img
                  src="/platform/curseforge.svg"
                  alt="CurseForge"
                  style={{ width: 30, height: 30, flexShrink: 0 }}
                />
                <Text style={{ width: 80, flexShrink: 0, fontFamily: "Inter", fontWeight: "bold" }}>CurseForge</Text>
                <Progress
                  percent={Math.round(
                    (progress.curseforge.done /
                      Math.max(progress.curseforge.total, 1)) *
                      100,
                  )}
                  status={
                    progress.curseforge.status === "failed"
                      ? "exception"
                      : undefined
                  }
                  format={() =>
                    `${progress.curseforge.done} / ${progress.curseforge.total}`
                  }
                  style={{ flex: 1 }}
                />
              </Flex>
            )}
          </Flex>
        </div>

        {/* Result */}
        {publishDone && publishResult && (
          <Alert
            type={publishResult.failed > 0 ? "warning" : "success"}
            title="发布结果"
            description={
              <div>
                <div>
                  成功 {publishResult.success} 个，失败{" "}
                  {publishResult.failed} 个
                </div>
                {platforms.map((platform) => {
                  const errors = publishResult.errors[platform];
                  if (errors.length === 0) return null;
                  const label =
                    platform === "modrinth" ? "Modrinth" : "CurseForge";
                  return (
                    <div key={platform} style={{ marginTop: token.marginSM }}>
                      <Text strong>{label}:</Text>
                      <ul style={{ margin: "4px 0 0", paddingLeft: 20 }}>
                        {errors.map((e, i) => (
                          <li key={i}>
                            <Text type="danger">{e}</Text>
                          </li>
                        ))}
                      </ul>
                    </div>
                  );
                })}
              </div>
            }
            showIcon
          />
        )}
      </div>
    );
  };

  // --------------- Render ---------------

  return (
    <Modal
      title="一键发布"
      open={open}
      onCancel={handleClose}
      width={1200}
      destroyOnHidden
      footer={
        publishing ? null : (
          <Space>
            {currentStep > 0 && currentStep < 2 && (
              <Button onClick={handlePrev}>上一步</Button>
            )}
            {currentStep === 0 ? (
              <Button type="primary" onClick={handleNext}>
                下一步
              </Button>
            ) : currentStep === 1 ? (
              <Button type="primary" onClick={handleConfirmPublish}>
                确认发布
              </Button>
            ) : (
              <Button type="primary" onClick={handleClose}>
                关闭
              </Button>
            )}
          </Space>
        )
      }
    >
      <Steps
        current={currentStep}
        size="small"
        style={{ marginBottom: 24 }}
        items={[
          { title: "版本选择" },
          { title: "发布设置" },
          { title: "发布进度" },
        ]}
      />

      {currentStep === 0
        ? renderStep1()
        : currentStep === 1
          ? renderStep2()
          : renderStep3()}
    </Modal>
  );
}