'use client';

import { Save } from 'lucide-react';
import { ICON_SIZE_MD } from '@/components/icons';
import React, { useEffect } from 'react';
import { Modal, Form, Row, Col, Button, InputNumber } from 'antd';
import { message } from '@/lib/feedback/message';
import { FormInput, FormTextarea, FormDatePicker } from '@/components/form';
import { useMutationCache } from '@/hooks/useMutationCache';
import { useWaygestFormModalProps, waygestFormModalFooterClassName } from '@/hooks/useWaygestFormModalProps';
import { API_ENDPOINTS } from '@/lib/api/endpoints';
import { Sprint } from '@/types';
import dayjs from 'dayjs';

export interface ModalSprintFormProps {
    open: boolean;
    onClose: () => void;
    /** ID do projeto (obrigatório em criação) */
    projetoId: string;
    /** Se informado, modo edição; senão, modo criação */
    sprint?: Sprint | null;
    /** Callback após criar/atualizar com sucesso */
    onSuccess?: () => void;
}

export function ModalSprintForm({
    open,
    onClose,
    projetoId,
    sprint,
    onSuccess}: ModalSprintFormProps) {
    const sprintFormModalLayout = useWaygestFormModalProps();
    const [form] = Form.useForm();
    const isEdit = !!sprint?.id;

    const createMutation = useMutationCache<Record<string, unknown>, Record<string, unknown>>({
        endpoint: API_ENDPOINTS.desenvolvimento.sprints.store,
        method: 'POST',
        invalidateQueries: [['desenvolvimento', 'sprints']],
        onSuccess: () => {
            message.success('Sprint criada com sucesso!');
            form.resetFields();
            onClose();
            onSuccess?.();
        },
        onError: (err: unknown) => {
            const errorMessage =
                (err as { response?: { data?: { message?: string } } })?.response?.data?.message ||
                'Erro ao criar sprint';
            message.error(errorMessage);
        }});

    type UpdateVariables = { id: number } & Record<string, unknown>;
    const updateMutation = useMutationCache<Record<string, unknown>, UpdateVariables>({
        endpoint: (vars) => API_ENDPOINTS.desenvolvimento.sprints.update(vars.id),
        method: 'PUT',
        invalidateQueries: [['desenvolvimento', 'sprints']],
        onSuccess: () => {
            message.success('Sprint atualizada com sucesso!');
            form.resetFields();
            onClose();
            onSuccess?.();
        },
        onError: (err: unknown) => {
            const errorMessage =
                (err as { response?: { data?: { message?: string } } })?.response?.data?.message ||
                'Erro ao atualizar sprint';
            message.error(errorMessage);
        }});

    useEffect(() => {
        if (!open) return;
        if (sprint) {
            form.setFieldsValue({
                nome: sprint.nome,
                descricao: sprint.descricao ?? '',
                data_inicio: sprint.data_inicio ? dayjs(sprint.data_inicio) : undefined,
                data_fim: sprint.data_fim ? dayjs(sprint.data_fim) : undefined,
                capacidade_planejada: sprint.capacidade_planejada ?? undefined,
                velocidade_planejada: sprint.velocidade_planejada ?? undefined});
        } else {
            form.resetFields();
        }
    }, [open, sprint, form]);

    const handleSubmit = async (values: Record<string, unknown>) => {
        const di = values.data_inicio as { isAfter?: (o: unknown, u?: string) => boolean } | undefined;
        const df = values.data_fim as { isBefore?: (o: unknown, u?: string) => boolean } | undefined;
        if (
            di &&
            df &&
            typeof df.isBefore === 'function' &&
            df.isBefore(di, 'day')
        ) {
            message.error('A data de término deve ser igual ou posterior à data de início.');
            return;
        }

        const payload = { ...values };
        if (
            payload.data_inicio &&
            typeof (payload.data_inicio as { format?: (f: string) => string })?.format === 'function'
        ) {
            payload.data_inicio = (payload.data_inicio as { format: (f: string) => string }).format(
                'YYYY-MM-DD'
            );
        }
        if (
            payload.data_fim &&
            typeof (payload.data_fim as { format?: (f: string) => string })?.format === 'function'
        ) {
            payload.data_fim = (payload.data_fim as { format: (f: string) => string }).format('YYYY-MM-DD');
        }
        if (!isEdit) {
            payload.projeto_id = projetoId ? Number(projetoId) : undefined;
        }
        if (isEdit && sprint?.id) {
            updateMutation.mutate({ id: sprint.id, ...payload } as UpdateVariables);
        } else {
            createMutation.mutate(payload as Record<string, unknown>);
        }
    };

    const handleCancel = () => {
        form.resetFields();
        onClose();
    };

    const isPending = createMutation.isPending || updateMutation.isPending;

    return (
        <Modal
            title={isEdit ? 'Editar Sprint' : 'Nova Sprint'}
            data-testid="projeto-sprint-form-modal"
            open={open}
            onCancel={handleCancel}
            footer={
                <div className={waygestFormModalFooterClassName}>
                    <Button onClick={handleCancel}>Cancelar</Button>
                    <Button
                        type="primary"
                        loading={isPending}
                        onClick={() => form.submit()}
                        icon={<Save size={ICON_SIZE_MD} aria-hidden />}
                    >
                        {isEdit ? 'Salvar' : 'Criar Sprint'}
                    </Button>
                </div>
            }
            width={sprintFormModalLayout.width ?? 560}
            centered={sprintFormModalLayout.centered ?? true}
            className={sprintFormModalLayout.className}

            styles={sprintFormModalLayout.styles ?? {}}
            destroyOnHidden
            keyboard
            focusTriggerAfterClose
        >
            <Form form={form} layout="vertical" onFinish={handleSubmit} size="large">
                <FormInput
                    name="nome"
                    label="Nome da Sprint"
                    required
                    placeholder="Ex: Sprint 1 - Q4 2024"
                />

                <FormTextarea
                    name="descricao"
                    label="Objetivo / descrição"
                    rows={3}
                    placeholder="Objetivo do ciclo, critério de sucesso e hipóteses de escopo..."
                    maxLength={1000}
                    showCount
                />

                <Row gutter={16}>
                    <Col xs={24} sm={12}>
                        <Form.Item
                            name="capacidade_planejada"
                            label="Capacidade planejada"
                            help="Pontos ou unidade acordada com o time — usada para comparar com o realizado."
                        >
                            <InputNumber min={0} style={{ width: '100%' }} placeholder="Ex.: 40" />
                        </Form.Item>
                    </Col>
                    <Col xs={24} sm={12}>
                        <Form.Item
                            name="velocidade_planejada"
                            label="Velocidade planejada"
                            help="Se o processo usa velocidade média, registre o alvo do ciclo."
                        >
                            <InputNumber min={0} style={{ width: '100%' }} placeholder="Ex.: 35" />
                        </Form.Item>
                    </Col>
                </Row>

                <Row gutter={16}>
                    <Col xs={24} sm={12}>
                        <FormDatePicker name="data_inicio" label="Data de Início" required format="DD/MM/YYYY" />
                    </Col>
                    <Col xs={24} sm={12}>
                        <FormDatePicker name="data_fim" label="Data de Término" required format="DD/MM/YYYY" />
                    </Col>
                </Row>

            </Form>
        </Modal>
    );
}