'use client';

/**
 * Modal de Sprint Review — registro da revisão da sprint
 * (padrão Waygest: `useWaygestFormModalProps`, como `ModalSprintPlanning`).
 */

import { Save } from 'lucide-react';
import { ICON_SIZE_MD } from '@/components/icons';
import React, { useEffect } from 'react';
import {
    Alert,
    Button,
    DatePicker,
    Descriptions,
    Form,
    Input,
    Modal,
    Select,
    Tag,
    Typography,
} from 'antd';
import { message } from '@/lib/feedback/message';
import { useQueryCache } from '@/hooks/useQueryCache';
import { useMutationCache } from '@/hooks/useMutationCache';
import {
    mergeWaygestFormModalBodyStyles,
    useWaygestFormModalProps,
    waygestFormModalFooterClassName,
} from '@/hooks/useWaygestFormModalProps';
import { API_ENDPOINTS } from '@/lib/api/endpoints';
import { queryKeys } from '@/lib/cache/queryKeys';
import type { Sprint, SprintRevisao } from '@/types/projeto';
import type { Usuario } from '@/types/usuario';
import dayjs from 'dayjs';

const { TextArea } = Input;
const { Paragraph } = Typography;

const statusSprintLabel: Record<string, string> = {
    planejada: 'Planejada',
    ativa: 'Ativa',
    concluida: 'Concluída',
    cancelada: 'Cancelada',
};

export interface ModalSprintReviewProps {
    open: boolean;
    onClose: () => void;
    sprintId: string;
    sprint?: Sprint | null;
    onSuccess?: () => void;
}

export function ModalSprintReview({
    open,
    onClose,
    sprintId,
    sprint: sprintProp,
    onSuccess,
}: ModalSprintReviewProps) {
    const formModalLayout = useWaygestFormModalProps();
    const [form] = Form.useForm();
    const sprintIdSafe = sprintId.trim();
    const enabled = open && Boolean(sprintIdSafe);

    const { data: sprintFetched } = useQueryCache<Sprint>({
        queryKey: queryKeys.desenvolvimento.sprints.detail(sprintIdSafe),
        endpoint: API_ENDPOINTS.desenvolvimento.sprints.show(sprintIdSafe),
        enabled: enabled && !sprintProp,
        staleTime: 1 * 60 * 1000,
    });

    const sprint = sprintProp ?? sprintFetched ?? null;

    const { data: revisaoData, isLoading: loadingRevisao } = useQueryCache<{
        data: SprintRevisao;
    }>({
        queryKey: queryKeys.desenvolvimento.sprintLegacy.revisao(sprintIdSafe),
        endpoint: API_ENDPOINTS.desenvolvimento.sprints.revisao(sprintIdSafe),
        enabled,
    });

    const { data: usuariosData } = useQueryCache<{ data: Usuario[] }>({
        queryKey: queryKeys.usuariosCatalog.list(),
        endpoint: API_ENDPOINTS.admin.usuarios.index,
        params: { per_page: 1000 },
        enabled,
    });

    const revisao = revisaoData?.data;
    const usuarios = usuariosData?.data ?? [];

    const objetivoSprint = sprint?.objetivo_sprint || sprint?.objetivo;
    const velPlan = sprint?.velocidade_planejada;
    const velReal = sprint?.velocidade_real;
    const desvioVel =
        typeof velPlan === 'number' && typeof velReal === 'number' && velPlan > 0
            ? Math.round(((velReal - velPlan) / velPlan) * 100)
            : null;

    useEffect(() => {
        if (!open) {
            return;
        }
        if (revisao) {
            form.setFieldsValue({
                realizado_em: revisao.realizado_em
                    ? dayjs(revisao.realizado_em)
                    : undefined,
                participantes: revisao.participantes,
                incrementos_apresentados: revisao.incrementos_apresentados,
                feedback: revisao.feedback,
            });
            return;
        }
        if (!loadingRevisao) {
            form.resetFields();
        }
    }, [open, revisao, loadingRevisao, form]);

    const saveMutation = useMutationCache<SprintRevisao, Record<string, unknown>>({
        endpoint: () => API_ENDPOINTS.desenvolvimento.sprints.salvarRevisao(sprintIdSafe),
        method: 'POST',
        invalidateQueries: [
            ['sprint', sprintIdSafe, 'revisao'],
            queryKeys.desenvolvimento.sprints.detail(sprintIdSafe),
        ],
        onSuccess: () => {
            message.success('Revisão da sprint salva com sucesso!');
            onSuccess?.();
            onClose();
        },
        onError: (error: unknown) => {
            const errorMessage =
                (error as { response?: { data?: { message?: string } } })?.response?.data
                    ?.message || 'Erro ao salvar revisão';
            message.error(errorMessage);
        },
    });

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

    const handleSubmit = async () => {
        try {
            const values = await form.validateFields();
            saveMutation.mutate({
                ...values,
                realizado_em: values.realizado_em
                    ? values.realizado_em.toISOString()
                    : undefined,
            });
        } catch {
            // Validação Ant Design — campos destacados no formulário.
        }
    };

    return (
        <Modal
            title="Sprint Review"
            data-testid="projeto-sprint-review-modal"
            open={open}
            onCancel={handleCancel}
            footer={
                <div className={waygestFormModalFooterClassName}>
                    <Button onClick={handleCancel}>Cancelar</Button>
                    <Button
                        type="primary"
                        loading={saveMutation.isPending}
                        onClick={() => void handleSubmit()}
                        icon={<Save size={ICON_SIZE_MD} aria-hidden />}
                    >
                        Salvar
                    </Button>
                </div>
            }
            width={formModalLayout.width ?? 720}
            centered={formModalLayout.centered ?? true}
            className={formModalLayout.className}
            zIndex={formModalLayout.zIndex}
            styles={mergeWaygestFormModalBodyStyles(formModalLayout)}
            destroyOnHidden
            keyboard
            focusTriggerAfterClose
        >
            {sprint ? (
                <div style={{ marginBottom: 16 }}>
                    <Paragraph strong>Resultado e compromisso</Paragraph>
                    <Descriptions
                        bordered
                        size="small"
                        column={{ xs: 1, sm: 2 }}
                        style={{ marginTop: 12 }}
                    >
                        <Descriptions.Item label="Período">
                            {sprint.data_inicio && sprint.data_fim
                                ? `${new Date(sprint.data_inicio).toLocaleDateString('pt-BR')} → ${new Date(sprint.data_fim).toLocaleDateString('pt-BR')}`
                                : '—'}
                        </Descriptions.Item>
                        <Descriptions.Item label="Estado da sprint">
                            <Tag
                                color={
                                    sprint.status === 'concluida'
                                        ? 'green'
                                        : sprint.status === 'ativa'
                                          ? 'blue'
                                          : 'default'
                                }
                            >
                                {statusSprintLabel[sprint.status] ?? sprint.status}
                            </Tag>
                        </Descriptions.Item>
                        <Descriptions.Item label="Objetivo (referência)" span={2}>
                            {objetivoSprint?.trim()
                                ? objetivoSprint
                                : 'Sem objetivo registrado na sprint — alinhe com o planning.'}
                        </Descriptions.Item>
                        <Descriptions.Item label="Velocidade planejada">
                            {velPlan ?? '—'}
                        </Descriptions.Item>
                        <Descriptions.Item label="Velocidade real">
                            {velReal ?? '—'}
                        </Descriptions.Item>
                        {desvioVel !== null ? (
                            <Descriptions.Item label="Desvio (real vs planejado)" span={2}>
                                <Tag
                                    color={
                                        desvioVel < 0
                                            ? 'orange'
                                            : desvioVel > 0
                                              ? 'green'
                                              : 'default'
                                    }
                                >
                                    {desvioVel > 0 ? '+' : ''}
                                    {desvioVel}%
                                </Tag>
                            </Descriptions.Item>
                        ) : null}
                    </Descriptions>
                </div>
            ) : null}

            <Alert
                type="info"
                showIcon
                style={{ marginBottom: 16 }}
                message="Demonstração de valor e aceite"
                description="Registre o que foi mostrado, o feedback dos stakeholders e o que fica explícito como aceite ou pendência para o backlog ou próxima sprint."
            />

            <Form form={form} layout="vertical" size="large">
                <Form.Item name="realizado_em" label="Data e hora da revisão">
                    <DatePicker
                        showTime
                        format="DD/MM/YYYY HH:mm"
                        style={{ width: '100%' }}
                    />
                </Form.Item>

                <Form.Item name="participantes" label="Participantes">
                    <Select
                        mode="multiple"
                        placeholder="Selecione os participantes"
                        showSearch
                        optionFilterProp="label"
                        options={usuarios.map((usuario) => ({
                            value: usuario.id,
                            label: usuario.nome,
                        }))}
                    />
                </Form.Item>

                <Form.Item
                    name="incrementos_apresentados"
                    label="Incrementos apresentados"
                    extra="Ligue cada incremento ao objetivo da sprint e ao critério de aceite acordado."
                >
                    <TextArea
                        rows={5}
                        placeholder="Descreva os incrementos de produto apresentados nesta revisão..."
                    />
                </Form.Item>

                <Form.Item
                    name="feedback"
                    label="Feedback recebido"
                    extra="Inclua pedidos de alteração, decisões de produto e itens a priorizar no backlog."
                >
                    <TextArea
                        rows={5}
                        placeholder="Registre o feedback recebido dos stakeholders..."
                    />
                </Form.Item>
            </Form>
        </Modal>
    );
}