// T600.25 (IIBB) — IngresosBrutosFormModal
// Modal de edición / creación de IngresosBrutos
// CRÍTICO: NO incluye campo Alícuota en modo edit (inmutable, cambiar via NuevaVersion)
import { useEffect } from 'react'
import { todayArgentina } from '@/lib/dateFormat'
import { useForm } from 'react-hook-form'
import { zodResolver } from '@hookform/resolvers/zod'
import { z } from 'zod'
import { isAxiosError } from 'axios'
import { AlertCircle } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Alert, AlertDescription } from '@/components/ui/alert'
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogHeader,
  DialogTitle,
  DialogFooter,
} from '@/components/ui/dialog'
import {
  Form,
  FormControl,
  FormField,
  FormItem,
  FormLabel,
  FormMessage,
} from '@/components/ui/form'
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/components/ui/select'
import { useCreateIngresosBrutos, useUpdateIngresosBrutos } from '../hooks/useIngresosBrutos'
import { PROVINCIAS, PROVINCIA_DISPLAY } from '../types/ingresosBrutos.types'
import type { IngresosBrutos, ProvinciaArgentina } from '../types/ingresosBrutos.types'
import { toast } from 'sonner'

const formSchema = z.object({
  provincia: z.string().min(1, 'La provincia es requerida'),
  descripcion: z
    .string()
    .min(1, 'La descripción es requerida')
    .max(200, 'Máximo 200 caracteres'),
  activo: z.boolean(),
  alicuotaCreate: z.coerce
    .number<number>('Debe ser un número')
    .min(0, 'Mínimo 0%')
    .max(100, 'Máximo 100%')
    .optional(),
  vigenciaDesde: z.string().optional(),
})

type FormValues = z.infer<typeof formSchema>

interface IngresosBrutosFormModalProps {
  open: boolean
  item: IngresosBrutos | null  // null = modo create
  onClose: () => void
  onSuccess: () => void
}

function resolveBackendError(err: unknown): string | null {
  if (!err) return null
  if (isAxiosError(err) && err.response?.data) {
    const data = err.response.data as { error?: string; message?: string }
    if (data.error === 'inmutable_usar_nueva_version') {
      return 'Para cambiar la alícuota usá el botón "Nueva vigencia" en lugar de "Editar".'
    }
    if (data.error === 'duplicate_provincia') {
      return data.message ?? 'Ya existe un registro para esa provincia'
    }
    return data.message ?? data.error ?? 'Error al guardar'
  }
  return 'Error al guardar. Intentá de nuevo.'
}

export function IngresosBrutosFormModal({
  open,
  item,
  onClose,
  onSuccess,
}: IngresosBrutosFormModalProps) {
  const isEdit = item != null
  const createMutation = useCreateIngresosBrutos()
  const updateMutation = useUpdateIngresosBrutos()

  const isPending = createMutation.isPending || updateMutation.isPending
  const error = createMutation.error ?? updateMutation.error

  const form = useForm<FormValues>({
    resolver: zodResolver(formSchema),
    defaultValues: {
      provincia: '',
      descripcion: '',
      activo: true,
      alicuotaCreate: undefined,
      vigenciaDesde: todayArgentina(),
    },
  })

  useEffect(() => {
    if (item) {
      form.reset({
        provincia: item.provincia,
        descripcion: item.descripcion,
        activo: item.activo,
        alicuotaCreate: undefined,
        vigenciaDesde: '',
      })
    } else {
      form.reset({
        provincia: '',
        descripcion: '',
        activo: true,
        alicuotaCreate: undefined,
        vigenciaDesde: todayArgentina(),
      })
    }
    createMutation.reset()
    updateMutation.reset()
  }, [item, open]) // eslint-disable-line react-hooks/exhaustive-deps

  const backendError = resolveBackendError(error)

  function handleSubmit(values: FormValues) {
    if (isEdit) {
      updateMutation.mutate(
        {
          id: item.id,
          body: {
            descripcion: values.descripcion,
            activo: values.activo,
          },
        },
        {
          onSuccess: () => {
            toast.success('Ingresos Brutos actualizado')
            onSuccess()
            onClose()
          },
        },
      )
    } else {
      if (values.alicuotaCreate === undefined) {
        form.setError('alicuotaCreate', { message: 'La alícuota es requerida' })
        return
      }
      createMutation.mutate(
        {
          provincia: values.provincia as ProvinciaArgentina,
          descripcion: values.descripcion,
          alicuota: values.alicuotaCreate,
          vigenciaDesde: values.vigenciaDesde ?? todayArgentina(),
        },
        {
          onSuccess: () => {
            toast.success('Ingresos Brutos creado')
            onSuccess()
            onClose()
          },
        },
      )
    }
  }

  return (
    <Dialog open={open} onOpenChange={(v) => { if (!v) onClose() }}>
      <DialogContent className="max-w-md">
        <DialogHeader>
          <DialogTitle>
            {isEdit ? 'Editar Ingresos Brutos' : 'Crear Ingresos Brutos'}
          </DialogTitle>
          <DialogDescription>
            {isEdit
              ? 'Modificá los datos de Ingresos Brutos. La alícuota no puede cambiarse aquí; usá "Nueva vigencia".'
              : 'Completá los datos para crear un nuevo registro de Ingresos Brutos con su alícuota inicial.'}
          </DialogDescription>
        </DialogHeader>

        <Form {...form}>
          <form onSubmit={form.handleSubmit(handleSubmit)} className="space-y-4" noValidate>
            {backendError && (
              <Alert variant="destructive">
                <AlertCircle className="h-4 w-4" />
                <AlertDescription>{backendError}</AlertDescription>
              </Alert>
            )}

            {/* Provincia — solo en create */}
            {!isEdit && (
              <FormField
                control={form.control}
                name="provincia"
                render={({ field }) => (
                  <FormItem>
                    <FormLabel>Provincia</FormLabel>
                    <Select
                      value={field.value}
                      onValueChange={field.onChange}
                      disabled={isPending}
                    >
                      <FormControl>
                        <SelectTrigger aria-label="Provincia">
                          <SelectValue placeholder="Seleccioná una provincia" />
                        </SelectTrigger>
                      </FormControl>
                      <SelectContent>
                        {PROVINCIAS.map((p) => (
                          <SelectItem key={p} value={p}>
                            {PROVINCIA_DISPLAY[p]}
                          </SelectItem>
                        ))}
                      </SelectContent>
                    </Select>
                    <FormMessage />
                  </FormItem>
                )}
              />
            )}

            {/* Descripción */}
            <FormField
              control={form.control}
              name="descripcion"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Descripción</FormLabel>
                  <FormControl>
                    <Input
                      {...field}
                      placeholder="Descripción del registro"
                      aria-label="Descripción"
                      disabled={isPending}
                    />
                  </FormControl>
                  <FormMessage />
                </FormItem>
              )}
            />

            {/* Solo en create: alícuota y vigenciaDesde */}
            {!isEdit && (
              <>
                <FormField
                  control={form.control}
                  name="alicuotaCreate"
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Alícuota inicial (%)</FormLabel>
                      <FormControl>
                        <Input
                          {...field}
                          type="number"
                          min={0}
                          max={100}
                          step={0.001}
                          placeholder="Ej: 2.5"
                          aria-label="Alícuota inicial"
                          disabled={isPending}
                        />
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  )}
                />

                <FormField
                  control={form.control}
                  name="vigenciaDesde"
                  render={({ field }) => (
                    <FormItem>
                      <FormLabel>Vigencia desde</FormLabel>
                      <FormControl>
                        <Input
                          {...field}
                          type="date"
                          aria-label="Vigencia desde"
                          disabled={isPending}
                        />
                      </FormControl>
                      <FormMessage />
                    </FormItem>
                  )}
                />
              </>
            )}

            {/* Nota informativa en modo EDIT */}
            {isEdit && (
              <p className="text-xs text-muted-foreground rounded-md border border-border bg-muted/50 p-3">
                💡 Para cambiar la alícuota usá el botón <strong>Nueva vigencia</strong> en la tabla.
              </p>
            )}

            <DialogFooter className="gap-2">
              <Button
                type="button"
                variant="ghost"
                onClick={onClose}
                disabled={isPending}
                aria-label="cancelar"
              >
                Cancelar
              </Button>
              <Button type="submit" disabled={isPending}>
                {isPending ? 'Guardando...' : 'Guardar cambios'}
              </Button>
            </DialogFooter>
          </form>
        </Form>
      </DialogContent>
    </Dialog>
  )
}
