"use client";

import * as React from "react";
import { zodResolver } from "@hookform/resolvers/zod";
import {
  AlertTriangle,
  BrainCircuit,
  Loader2,
  Plus,
  Sparkles,
  Trash2,
} from "lucide-react";
import { useForm } from "react-hook-form";
import { toast } from "sonner";
import { z } from "zod";

import type {
  AiCaseExtractionResponse,
  AiExtractedCase,
} from "@/ai/schemas/extract-case";
import { AiCaseResultPanel } from "@/components/ai/ai-case-result-panel";
import { Button } from "@/components/ui/button";
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
import { Textarea } from "@/components/ui/textarea";
import { requestAiCaseExtraction } from "@/services/ai-case.service";
import { runInheritanceCalculation } from "@/services/inheritance.service";
import { HEIR_LABELS, HEIR_TYPES, type HeirType, type InheritanceResult } from "@/types/inheritance";
import { formatCurrency } from "@/utils/formatting";

const caseInputSchema = z.object({
  text: z
    .string()
    .trim()
    .min(10, "Please enter more details so AI can extract heirs correctly."),
});

type CaseInputForm = z.infer<typeof caseInputSchema>;

const examplePlaceholders = [
  "My father passed away leaving behind 2 daughters and his wife.",
  "A woman died and left behind her husband, mother and one son.",
];

function mapToInheritanceInput(extractedCase: AiExtractedCase) {
  return {
    madhab: "hanafi" as const,
    estate: {
      totalEstate: extractedCase.estateAmount ?? 0,
      currency: "USD",
      debts: extractedCase.debts ?? 0,
      funeralExpenses: 0,
      wasiyyahAmount: extractedCase.wasiyyah ?? 0,
    },
    heirs: HEIR_TYPES.map((type) => ({
      type,
      count: extractedCase.heirs.find((heir) => heir.type === type)?.quantity ?? 0,
    })),
  };
}

export function AiCaseWorkflow() {
  const [isExtracting, setIsExtracting] = React.useState(false);
  const [apiError, setApiError] = React.useState<string | null>(null);
  const [warnings, setWarnings] = React.useState<string[]>([]);
  const [reviewCase, setReviewCase] = React.useState<AiExtractedCase | null>(null);
  const [result, setResult] = React.useState<InheritanceResult | null>(null);
  const [newHeirType, setNewHeirType] = React.useState<HeirType>("son");
  const [newHeirQuantity, setNewHeirQuantity] = React.useState(1);

  const form = useForm<CaseInputForm>({
    resolver: zodResolver(caseInputSchema),
    defaultValues: {
      text: "",
    },
  });

  const handleGenerateCase = form.handleSubmit(async (values) => {
    setIsExtracting(true);
    setApiError(null);
    setWarnings([]);
    setResult(null);

    try {
      const payload: AiCaseExtractionResponse = await requestAiCaseExtraction(
        values.text,
      );

      if (!payload.success) {
        const message = payload.message || "Extraction failed.";
        setApiError(message);
        toast.error(message);
        return;
      }

      setReviewCase(payload.case);
      setWarnings(payload.warnings);
      toast.success("Case extracted. Review and adjust before calculation.");
    } catch {
      const message = "Unable to process AI extraction request.";
      setApiError(message);
      toast.error(message);
    } finally {
      setIsExtracting(false);
    }
  });

  const updateHeirQuantity = (type: HeirType, quantity: number) => {
    if (!reviewCase) return;

    const safeQuantity = Math.max(1, Math.min(10, quantity));
    setReviewCase({
      ...reviewCase,
      heirs: reviewCase.heirs.map((heir) =>
        heir.type === type ? { ...heir, quantity: safeQuantity } : heir,
      ),
    });
  };

  const removeHeir = (type: HeirType) => {
    if (!reviewCase) return;

    setReviewCase({
      ...reviewCase,
      heirs: reviewCase.heirs.filter((heir) => heir.type !== type),
    });
  };

  const addHeir = () => {
    if (!reviewCase) return;

    const existing = reviewCase.heirs.find((heir) => heir.type === newHeirType);
    if (existing) {
      updateHeirQuantity(newHeirType, existing.quantity + newHeirQuantity);
      return;
    }

    setReviewCase({
      ...reviewCase,
      heirs: [...reviewCase.heirs, { type: newHeirType, quantity: newHeirQuantity }],
    });
  };

  const calculateFromReviewedCase = () => {
    if (!reviewCase) return;

    if (!reviewCase.estateAmount || reviewCase.estateAmount <= 0) {
      toast.error("Please set a valid estate amount before calculation.");
      return;
    }

    if (reviewCase.heirs.length === 0) {
      toast.error("Please keep at least one heir before calculation.");
      return;
    }

    try {
      const input = mapToInheritanceInput(reviewCase);
      const calculated = runInheritanceCalculation(input);
      setResult(calculated);
      toast.success("Inheritance calculation completed.");
    } catch (error) {
      const message =
        error instanceof Error
          ? error.message
          : "Failed to calculate inheritance from extracted case.";
      toast.error(message);
    }
  };

  return (
    <div className="mx-auto w-full max-w-5xl space-y-6 px-4 py-8 sm:px-6 lg:px-8">
      <Card className="border border-border bg-card">
        <CardHeader>
          <CardTitle className="flex items-center gap-2 text-xl text-emerald-900">
            <BrainCircuit className="size-5" />
            AI Case Extraction
          </CardTitle>
          <CardDescription>
            Describe an inheritance case in natural language. AI extracts heirs and estate details
            into a structured legal case draft.
          </CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
          <div className="space-y-1.5">
            <Label htmlFor="case-text">Case Description</Label>
            <Textarea
              id="case-text"
              rows={8}
              placeholder={examplePlaceholders.join("\n")}
              {...form.register("text")}
            />
            {form.formState.errors.text ? (
              <p className="text-xs text-destructive">{form.formState.errors.text.message}</p>
            ) : null}
          </div>

          <div className="rounded-lg border border-border bg-muted/30 p-3">
            <p className="text-xs font-medium uppercase tracking-wide text-muted-foreground">
              Example Inputs
            </p>
            <ul className="mt-2 space-y-1 text-sm text-emerald-900">
              {examplePlaceholders.map((example) => (
                <li key={example} className="flex gap-2">
                  <Sparkles className="mt-0.5 size-3.5 text-emerald-700" />
                  <span>{example}</span>
                </li>
              ))}
            </ul>
          </div>

          {apiError ? (
            <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
              {apiError}
            </div>
          ) : null}

          <Button
            type="button"
            onClick={handleGenerateCase}
            disabled={isExtracting}
            className="bg-emerald-700 hover:bg-emerald-800"
          >
            {isExtracting ? (
              <>
                <Loader2 className="size-4 animate-spin" />
                Generating Case...
              </>
            ) : (
              "Generate Case"
            )}
          </Button>
        </CardContent>
      </Card>

      {reviewCase ? (
        <Card>
          <CardHeader>
            <CardTitle className="text-lg text-emerald-900">Structured Case Review</CardTitle>
            <CardDescription>
              Edit extracted fields before running inheritance calculation.
            </CardDescription>
          </CardHeader>
          <CardContent className="space-y-5">
            {warnings.length > 0 ? (
              <div className="rounded-lg border border-amber-300 bg-amber-50 p-3 text-sm text-amber-900">
                <p className="mb-1 flex items-center gap-1 font-medium">
                  <AlertTriangle className="size-4" />
                  Validation notices
                </p>
                <ul className="list-disc space-y-1 pl-5">
                  {warnings.map((warning) => (
                    <li key={warning}>{warning}</li>
                  ))}
                </ul>
              </div>
            ) : null}

            <div className="grid gap-4 sm:grid-cols-2">
              <div className="space-y-1.5">
                <Label>Deceased Gender</Label>
                <Select
                  value={reviewCase.deceasedGender}
                  onValueChange={(value) =>
                    setReviewCase({
                      ...reviewCase,
                      deceasedGender: value as "male" | "female" | "unknown",
                    })
                  }
                >
                  <SelectTrigger>
                    <SelectValue />
                  </SelectTrigger>
                  <SelectContent>
                    <SelectItem value="male">Male</SelectItem>
                    <SelectItem value="female">Female</SelectItem>
                    <SelectItem value="unknown">Unknown</SelectItem>
                  </SelectContent>
                </Select>
              </div>

              <div className="space-y-1.5">
                <Label>Estate Amount (USD)</Label>
                <Input
                  type="number"
                  min="0"
                  step="0.01"
                  value={reviewCase.estateAmount ?? ""}
                  onChange={(event) =>
                    setReviewCase({
                      ...reviewCase,
                      estateAmount:
                        event.target.value === "" ? null : Number(event.target.value),
                    })
                  }
                />
              </div>

              <div className="space-y-1.5">
                <Label>Debts (USD)</Label>
                <Input
                  type="number"
                  min="0"
                  step="0.01"
                  value={reviewCase.debts ?? ""}
                  onChange={(event) =>
                    setReviewCase({
                      ...reviewCase,
                      debts: event.target.value === "" ? null : Number(event.target.value),
                    })
                  }
                />
              </div>

              <div className="space-y-1.5">
                <Label>Wasiyyah (USD)</Label>
                <Input
                  type="number"
                  min="0"
                  step="0.01"
                  value={reviewCase.wasiyyah ?? ""}
                  onChange={(event) =>
                    setReviewCase({
                      ...reviewCase,
                      wasiyyah:
                        event.target.value === "" ? null : Number(event.target.value),
                    })
                  }
                />
              </div>
            </div>

            <div className="rounded-lg border border-border bg-muted/20 p-3">
              <p className="text-sm font-medium text-emerald-900">Detected Heirs</p>
              <div className="mt-3 grid gap-3 sm:grid-cols-2">
                {reviewCase.heirs.map((heir) => (
                  <div key={heir.type} className="rounded-md border border-border bg-card p-3">
                    <div className="flex items-center justify-between">
                      <p className="text-sm font-semibold text-emerald-900">{HEIR_LABELS[heir.type]}</p>
                      <Button
                        type="button"
                        size="icon-sm"
                        variant="ghost"
                        onClick={() => removeHeir(heir.type)}
                        aria-label={`Remove ${heir.type}`}
                      >
                        <Trash2 className="size-4" />
                      </Button>
                    </div>
                    <div className="mt-2 flex items-center gap-2">
                      <Button
                        type="button"
                        size="icon-sm"
                        variant="outline"
                        onClick={() => updateHeirQuantity(heir.type, heir.quantity - 1)}
                      >
                        -
                      </Button>
                      <Input
                        type="number"
                        min="1"
                        max="10"
                        value={heir.quantity}
                        onChange={(event) =>
                          updateHeirQuantity(heir.type, Number(event.target.value || 1))
                        }
                      />
                      <Button
                        type="button"
                        size="icon-sm"
                        variant="outline"
                        onClick={() => updateHeirQuantity(heir.type, heir.quantity + 1)}
                      >
                        +
                      </Button>
                    </div>
                  </div>
                ))}
              </div>
            </div>

            <div className="rounded-lg border border-dashed border-border p-3">
              <p className="text-sm font-medium text-emerald-900">Add Heir</p>
              <div className="mt-2 grid gap-3 sm:grid-cols-3">
                <Select
                  value={newHeirType}
                  onValueChange={(value) => setNewHeirType(value as HeirType)}
                >
                  <SelectTrigger>
                    <SelectValue />
                  </SelectTrigger>
                  <SelectContent>
                    {HEIR_TYPES.map((type) => (
                      <SelectItem key={type} value={type}>
                        {HEIR_LABELS[type]}
                      </SelectItem>
                    ))}
                  </SelectContent>
                </Select>

                <Input
                  type="number"
                  min="1"
                  max="10"
                  value={newHeirQuantity}
                  onChange={(event) =>
                    setNewHeirQuantity(Math.max(1, Math.min(10, Number(event.target.value || 1))))
                  }
                />

                <Button type="button" variant="outline" onClick={addHeir}>
                  <Plus className="size-4" />
                  Add
                </Button>
              </div>
            </div>

            <div className="flex flex-wrap gap-2">
              <Button onClick={calculateFromReviewedCase}>Continue to Calculation Engine</Button>
              <Button
                variant="outline"
                onClick={() => {
                  setReviewCase(null);
                  setResult(null);
                  setWarnings([]);
                }}
              >
                Reset Review
              </Button>
            </div>
          </CardContent>
        </Card>
      ) : null}

      {reviewCase?.estateAmount ? (
        <Card className="border border-emerald-100 bg-emerald-50/50">
          <CardContent className="py-4 text-sm text-emerald-900">
            Estimated estate to distribute: {formatCurrency(reviewCase.estateAmount, "USD")}
          </CardContent>
        </Card>
      ) : null}

      {result ? <AiCaseResultPanel result={result} currency="USD" /> : null}
    </div>
  );
}