"use client";

import { Button, Space, Typography, message } from "antd";
import { useParams, useRouter } from "next/navigation";
import { useEffect, useState } from "react";

import {
  VulnerabilityEditorForm,
  type VulnerabilityEditorInitialValues,
} from "@/app/dashboard/vulnerabilities/_components/vulnerability-editor-form";
import { PageStateNotice } from "@/components/common/page-state-notice";
import {
  fetchVulnerability,
  updateVulnerability,
  type UpdateVulnerabilityPayload,
} from "@/lib/api/vulnerabilities";
import type { VulnerabilityDetail } from "@/types/models";

const { Title, Paragraph } = Typography;

function getErrorStatus(error: unknown): number | undefined {
  const candidate = error as { response?: { status?: number } } | undefined;
  return candidate?.response?.status;
}

function toInitialValues(
  vulnerability: VulnerabilityDetail,
): VulnerabilityEditorInitialValues {
  return {
    title: vulnerability.title,
    severity_level: vulnerability.severity_level,
    vulnerability_type: vulnerability.vulnerability_type,
    discoverer_employee_id: vulnerability.discoverer_employee_id,
    fixer_employee_id: vulnerability.fixer_employee_id,
    owner_employee_id: vulnerability.owner_employee_id,
    department_id: vulnerability.department_id,
    application: vulnerability.application,
    code_repository: vulnerability.code_repository,
    interface_path: vulnerability.interface_path,
    discovery_channel: vulnerability.discovery_channel,
    discovery_phase: vulnerability.discovery_phase,
    network_env: vulnerability.network_env,
    source: vulnerability.source,
    has_poc_verification: vulnerability.has_poc_verification,
    is_third_party: vulnerability.is_third_party,
    tags: vulnerability.tags,
    affected_assets_count: vulnerability.affected_assets_count,
    dependency_name: vulnerability.dependency_name,
    dependency_version: vulnerability.dependency_version,
    verification_steps: vulnerability.verification_steps,
    poc_text: vulnerability.poc_text,
    submitted_at: vulnerability.submitted_at,
    sla_deadline: vulnerability.sla_deadline,
  };
}

export default function EditVulnerabilityPage() {
  const params = useParams<{ publicId: string }>();
  const router = useRouter();
  const [vulnerability, setVulnerability] =
    useState<VulnerabilityDetail | null>(null);
  const [actions, setActions] = useState<string[]>([]);
  const [loading, setLoading] = useState(true);
  const [loadError, setLoadError] = useState<string | null>(null);
  const [forbidden, setForbidden] = useState(false);
  const [viewDenied, setViewDenied] = useState(false);
  const routePublicId = params.publicId?.trim() || "";

  useEffect(() => {
    if (!routePublicId) {
      message.error("Invalid vulnerability public ID");
      router.push("/dashboard/vulnerabilities/list");
      return;
    }
    const load = async () => {
      setLoading(true);
      setLoadError(null);
      setForbidden(false);
      setViewDenied(false);
      try {
        const payload = await fetchVulnerability(routePublicId);
        if (!payload.vulnerability.public_id?.trim()) {
          setLoadError("Vulnerability public ID is missing from the response.");
          return;
        }
        if (!(payload.actions || []).includes("edit_details")) {
          setForbidden(true);
          setActions(payload.actions || []);
          return;
        }
        setVulnerability(payload.vulnerability);
        setActions(payload.actions || []);
      } catch (error) {
        if (getErrorStatus(error) === 403) {
          setViewDenied(true);
        } else {
          setLoadError("Failed to load vulnerability editor.");
        }
      } finally {
        setLoading(false);
      }
    };
    void load();
  }, [routePublicId, router]);

  if (loading) {
    return (
      <PageStateNotice
        tone="loading"
        title="Loading editor"
        description="Fetching vulnerability details and permissions."
      />
    );
  }

  if (forbidden) {
    return (
      <PageStateNotice
        tone="unavailable"
        title="Editing is not available"
        description="Your current role cannot edit this vulnerability."
        actions={
          <Button
            type="primary"
            onClick={() => router.push(`/dashboard/vulnerabilities/${routePublicId}`)}
          >
            Back to detail
          </Button>
        }
      />
    );
  }

  if (viewDenied) {
    return (
      <PageStateNotice
        tone="unavailable"
        title="You cannot view this vulnerability"
        description="This record is restricted for your current account, so the editor is not available here."
        actions={
          <Button
            type="primary"
            onClick={() => router.push("/dashboard/vulnerabilities/list")}
          >
            Back to list
          </Button>
        }
      />
    );
  }

  if (loadError || !vulnerability || !actions.includes("edit_details")) {
    return (
      <PageStateNotice
        tone="error"
        title="Unable to open the editor"
        description={loadError || "This vulnerability could not be loaded."}
        actions={
          <Button
            onClick={() => router.push("/dashboard/vulnerabilities/list")}
          >
            Back to list
          </Button>
        }
      />
    );
  }

  const handleSubmit = async (payload: UpdateVulnerabilityPayload) => {
    const currentPublicId = vulnerability.public_id?.trim();
    if (!currentPublicId) {
      throw new Error("Vulnerability public ID is missing.");
    }
    await updateVulnerability(currentPublicId, payload);
    message.success("Vulnerability updated");
    router.push(`/dashboard/vulnerabilities/${currentPublicId}`);
  };

  return (
    <Space direction="vertical" size={16} style={{ width: "100%" }}>
      <div>
        <Title level={3} style={{ marginBottom: 4 }}>
          Edit Vulnerability
        </Title>
        <Paragraph type="secondary" style={{ margin: 0 }}>
          Update the core finding details without changing status, comments, or
          authorized viewers.
        </Paragraph>
      </div>

      <VulnerabilityEditorForm
        mode="edit"
        initialValues={toInitialValues(vulnerability)}
        initialDescription={vulnerability.description || ""}
        editorResetKey={vulnerability.public_id || routePublicId}
        submitLabel="Save changes"
        onSubmit={handleSubmit}
        onCancel={() =>
          router.push(`/dashboard/vulnerabilities/${vulnerability.public_id}`)
        }
        cancelLabel="Back to detail"
      />
    </Space>
  );
}