'use client';

/**
 * Modal de Sprint Planning — registro do planejamento da sprint
 * (padrão Waygest: `useWaygestFormModalProps`, como `ModalSprintForm`).
 */

import { Save } from 'lucide-react';
import { ICON_SIZE_MD } from '@/components/icons';
import React, { useEffect } from 'react';
import {
    Alert,
    Button,
    Col,
    DatePicker,
    Form,
    Input,
    InputNumber,
    Modal,
    Progress,
    Row,
    Select,
    Statistic,
    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, SprintPlanejamento } from '@/types/projeto';
import type { Usuario } from '@/types/usuario';
import dayjs from 'dayjs';

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

export interface ModalSprintPlanningProps {
    open: boolean;
    onClose: () => void;
    sprintId: string;
    /** Sprint já carregada no detalhe (evita refetch quando disponível). */
    sprint?: Sprint | null;
    onSuccess?: () => void;
}

export function ModalSprintPlanning({
    open,
    onClose,
    sprintId,
    sprint: sprintProp,
    onSuccess,
}: ModalSprintPlanningProps) {
    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: planejamentoData, isLoading: loadingPlanejamento } = useQueryCache<{
        data: SprintPlanejamento;
    }>({
        queryKey: queryKeys.desenvolvimento.sprintLegacy.planejamento(sprintIdSafe),
        endpoint: API_ENDPOINTS.desenvolvimento.sprints.planejamento(sprintIdSafe),
        enabled,
    });

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

    const planejamento = planejamentoData?.data;
    const usuarios = usuariosData?.data ?? [];

    const capPlan = sprint?.capacidade_planejada;
    const velPlan = sprint?.velocidade_planejada;
    const capReal = sprint?.capacidade_realizada;
    const velReal = sprint?.velocidade_real;
    const usoCapacidadePct =
        typeof capPlan === 'number' && capPlan > 0 && typeof velPlan === 'number'
            ? Math.min(150, Math.round((velPlan / capPlan) * 100))
            : null;
    const riscoSobrecarga = usoCapacidadePct !== null && usoCapacidadePct > 100;
    const riscoSubPlanejamento = usoCapacidadePct !== null && usoCapacidadePct < 50;

    useEffect(() => {
        if (!open) {
            return;
        }
        if (planejamento) {
            form.setFieldsValue({
                realizado_em: planejamento.realizado_em
                    ? dayjs(planejamento.realizado_em)
                    : undefined,
                duracao_minutos: planejamento.duracao_minutos,
                participantes: planejamento.participantes,
                decisoes: planejamento.decisoes,
                objetivo_sprint: planejamento.objetivo_sprint,
            });
            return;
        }
        if (!loadingPlanejamento) {
            form.resetFields();
        }
    }, [open, planejamento, loadingPlanejamento, form]);

    const saveMutation = useMutationCache<SprintPlanejamento, Record<string, unknown>>({
        endpoint: () => API_ENDPOINTS.desenvolvimento.sprints.salvarPlanejamento(sprintIdSafe),
        method: 'POST',
        invalidateQueries: [
            ['sprint', sprintIdSafe, 'planejamento'],
            queryKeys.desenvolvimento.sprints.detail(sprintIdSafe),
        ],
        onSuccess: () => {
            message.success('Planejamento da sprint salvo com sucesso!');
            onSuccess?.();
            onClose();
        },
        onError: (error: unknown) => {
            const errorMessage =
                (error as { response?: { data?: { message?: string } } })?.response?.data
                    ?.message || 'Erro ao salvar planejamento';
            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 Planning"
            data-testid="projeto-sprint-planning-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 style={{ marginBottom: 12 }}>
                        Capacidade e compromisso (referência da sprint)
                    </Paragraph>
                    <Row gutter={[16, 16]}>
                        <Col xs={24} sm={12} md={6}>
                            <Statistic title="Capacidade planejada" value={capPlan ?? '—'} />
                        </Col>
                        <Col xs={24} sm={12} md={6}>
                            <Statistic title="Velocidade planejada" value={velPlan ?? '—'} />
                        </Col>
                        <Col xs={24} sm={12} md={6}>
                            <Statistic title="Capacidade realizada" value={capReal ?? '—'} />
                        </Col>
                        <Col xs={24} sm={12} md={6}>
                            <Statistic title="Velocidade real" value={velReal ?? '—'} />
                        </Col>
                    </Row>
                    {usoCapacidadePct !== null ? (
                        <div style={{ marginTop: 16 }}>
                            <Paragraph type="secondary" style={{ marginBottom: 8 }}>
                                Uso da capacidade planejada (velocidade planejada / capacidade
                                planejada)
                            </Paragraph>
                            <Progress
                                percent={Math.min(100, usoCapacidadePct)}
                                status={riscoSobrecarga ? 'exception' : 'active'}
                                format={() => `${usoCapacidadePct}%`}
                            />
                        </div>
                    ) : null}
                    {riscoSobrecarga ? (
                        <Alert
                            type="warning"
                            showIcon
                            style={{ marginTop: 16 }}
                            message="Risco de sobrecarga"
                            description="A velocidade planejada excede a capacidade registrada. Ajuste o escopo, a capacidade ou o objetivo antes de fechar o compromisso."
                        />
                    ) : null}
                    {riscoSubPlanejamento && !riscoSobrecarga ? (
                        <Alert
                            type="info"
                            showIcon
                            style={{ marginTop: 16 }}
                            message="Capacidade subutilizada"
                            description="Há folga em relação à capacidade planejada. Confirme se o saldo é intencional (buffer) ou se faltam itens no backlog da sprint."
                        />
                    ) : null}
                </div>
            ) : null}

            <Alert
                type="info"
                showIcon
                style={{ marginBottom: 16 }}
                message="Alinhar objetivo ao escopo"
                description="Use o objetivo da sprint e as decisões para documentar cortes, dependências e o que entra fora do compromisso — isso reduz desvios e ambiguidade na review."
            />

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

                <Form.Item name="duracao_minutos" label="Duração (minutos)">
                    <InputNumber
                        min={0}
                        style={{ width: '100%' }}
                        placeholder="Ex.: 120 (2 horas)"
                    />
                </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="objetivo_sprint"
                    label="Objetivo da sprint"
                    extra="Deve ser verificável na review: o que é sucesso para esta sprint?"
                >
                    <TextArea rows={3} placeholder="Defina o objetivo desta sprint..." />
                </Form.Item>

                <Form.Item
                    name="decisoes"
                    label="Decisões tomadas"
                    extra="Inclua cortes de escopo, itens adiados, dependências externas e dono da decisão."
                >
                    <TextArea
                        rows={5}
                        placeholder="Registre as decisões importantes tomadas durante o planejamento..."
                    />
                </Form.Item>
            </Form>
        </Modal>
    );
}