'use client';

import { confirmDialog } from '@/lib/feedback/confirmDialog';
import { ICON_SIZE_MD, FaClassIcon } from '@/components/icons';
import { Eye, Trash2 } from 'lucide-react';
import React, { useState } from 'react';
import { Input, Modal } from 'antd';
import { message } from '@/lib/feedback/message';
import { ModalOpcoesBase, type ModalOpcaoAction } from '@/components/ModalOpcoesBase/ModalOpcoesBase';
import apiClient from '@/lib/api/client';
import { API_ENDPOINTS } from '@/lib/api/endpoints';
import type { LogEntry } from '../types';

export interface ModalOpcoesLogProps {
    open: boolean;
    onClose: () => void;
    log: LogEntry | null;
    onVerDetalhes: (log: LogEntry) => void;
    /** Chamado após exclusão bem-sucedida (para invalidar lista e fechar) */
    onExcluido?: () => void;
    /** Se true, oculta "Ver detalhes" (ex.: já está na página de detalhes) */
    somenteExcluir?: boolean;
    /** Oculta ações de gestão (marcar realizado / excluir) quando false */
    podeGerenciar?: boolean;
}

export function ModalOpcoesLog({
    open,
    onClose,
    log,
    onVerDetalhes,
    onExcluido,
    somenteExcluir = false,
    podeGerenciar = true,
}: ModalOpcoesLogProps) {
    const [excluindo, setExcluindo] = useState(false);
    const [marcandoRealizado, setMarcandoRealizado] = useState(false);
    const [notaModalOpen, setNotaModalOpen] = useState(false);
    const [resolutionNoteDraft, setResolutionNoteDraft] = useState('');
    const [pendingResolve, setPendingResolve] = useState<{ resolved: boolean; resolveSameSlug: boolean } | null>(
        null,
    );

    const handleMarcarRealizado = async (
        resolved: boolean,
        resolveSameSlug = false,
        resolutionNote?: string,
    ) => {
        if (!log) return;
        setMarcandoRealizado(true);
        try {
            const res = await apiClient.put(API_ENDPOINTS.projetos.logs.update(log.id), {
                resolved,
                resolve_same_slug: resolveSameSlug,
                resolution_note: resolutionNote ?? undefined,
            });
            const data = res?.data as { updated_count?: number } | undefined;
            const count = data?.updated_count;
            if (resolved && resolveSameSlug && typeof count === 'number' && count > 1) {
                message.success(`${count} logs marcados como realizados.`);
            } else {
                message.success(resolved ? 'Log marcado como realizado.' : 'Log desmarcado como realizado.');
            }
            setNotaModalOpen(false);
            setResolutionNoteDraft('');
            setPendingResolve(null);
            onClose();
            onExcluido?.();
        } catch (err: unknown) {
            const msg =
                err && typeof err === 'object' && 'response' in err
                    ? (err as { response?: { data?: { message?: string } } }).response?.data?.message
                    : 'Erro ao atualizar o log.';
            message.error(msg || 'Erro ao atualizar o log.');
        } finally {
            setMarcandoRealizado(false);
        }
    };

    const abrirNotaResolucao = (resolved: boolean, resolveSameSlug: boolean) => {
        setPendingResolve({ resolved, resolveSameSlug });
        setResolutionNoteDraft(log?.resolution_note ?? '');
        setNotaModalOpen(true);
    };

    const podeResolverTodosComMesmoSlug =
        !!log?.slug && (log?.pending_same_slug_count ?? 0) > 1 && !log?.resolved_at;

    const escolherMarcarRealizado = () => {
        if (!log) return;
        if (podeResolverTodosComMesmoSlug) {
            confirmDialog({
                title: 'Marcar como realizado',
                content: `Aplicar apenas a este log ou a todos os ${log.pending_same_slug_count} pendentes com o mesmo erro (${log.slug})?`,
                okText: `Todos os ${log.pending_same_slug_count} pendentes`,
                cancelText: 'Só este log',
                onOk: () => abrirNotaResolucao(true, true),
                onCancel: () => abrirNotaResolucao(true, false),
            });
        } else {
            abrirNotaResolucao(true, false);
        }
    };

    const escolherDesmarcarRealizado = () => {
        if (!log) return;
        if (log.slug && (log.pending_same_slug_count ?? 0) > 1) {
            confirmDialog({
                title: 'Desmarcar como realizado',
                content: `Desmarcar apenas este log ou todos os logs com o mesmo erro (${log.slug})?`,
                okText: 'Todos com o mesmo erro',
                cancelText: 'Só este log',
                onOk: () => void handleMarcarRealizado(false, true),
                onCancel: () => void handleMarcarRealizado(false, false),
            });
        } else {
            void handleMarcarRealizado(false, false);
        }
    };

    const handleExcluir = async () => {
        if (!log) return;
        setExcluindo(true);
        try {
            await apiClient.delete(API_ENDPOINTS.projetos.logs.destroy(log.id));
            message.success('Log excluído com sucesso.');
            onClose();
            onExcluido?.();
        } catch (err: unknown) {
            const msg =
                err && typeof err === 'object' && 'response' in err
                    ? (err as { response?: { data?: { message?: string } } }).response?.data?.message
                    : 'Erro ao excluir o log.';
            message.error(msg || 'Erro ao excluir o log.');
        } finally {
            setExcluindo(false);
        }
    };

    const confirmarExcluir = () => {
        confirmDialog({
            title: 'Excluir log?',
            content: `O log #${log?.id} será excluído permanentemente.`,
            okText: 'Excluir',
            okType: 'danger',
            cancelText: 'Cancelar',
            onOk: handleExcluir,
        });
    };

    if (!log) return null;

    const subtitle = [`#${log.id}`, log.level?.toUpperCase(), log.header || log.message?.slice(0, 40)]
        .filter(Boolean)
        .join(' · ');

    const actions: ModalOpcaoAction[] = [];

    if (!somenteExcluir) {
        actions.push({
            key: 'ver',
            label: 'Ver detalhes',
            icon: <Eye size={ICON_SIZE_MD} aria-hidden />,
            onClick: () => {
                onClose();
                onVerDetalhes(log);
            },
            primary: true,
        });
    }

    const isResolved = !!log.resolved_at;
    if (podeGerenciar) {
        actions.push({
            key: 'realizado',
            label: isResolved
                ? marcandoRealizado
                    ? 'Desmarcando...'
                    : 'Desmarcar como realizado'
                : marcandoRealizado
                  ? 'Marcando...'
                  : 'Marcar como realizado',
            icon: <FaClassIcon icon={`fas fa-${isResolved ? 'undo' : 'check-circle'}`} />,
            onClick: () => (isResolved ? escolherDesmarcarRealizado() : escolherMarcarRealizado()),
            disabled: marcandoRealizado,
        });

        actions.push({
            key: 'excluir',
            label: excluindo ? 'Excluindo...' : 'Excluir',
            icon: <Trash2 size={ICON_SIZE_MD} aria-hidden />,
            onClick: confirmarExcluir,
            danger: true,
            disabled: excluindo,
        });
    }

    return (
        <>
            <ModalOpcoesBase
                data-testid="suporte-log-opcoes-modal"
                open={open}
                onClose={onClose}
                title="Opções do log"
                subtitle={subtitle}
                actions={actions}
                width={380}
            />
            <Modal
                title="Nota de resolução (opcional)"
                open={notaModalOpen}
                onCancel={() => {
                    setNotaModalOpen(false);
                    setPendingResolve(null);
                }}
                onOk={() => {
                    if (!pendingResolve) return;
                    void handleMarcarRealizado(
                        pendingResolve.resolved,
                        pendingResolve.resolveSameSlug,
                        resolutionNoteDraft.trim() || undefined,
                    );
                }}
                okText="Marcar como realizado"
                confirmLoading={marcandoRealizado}
                destroyOnClose
            >
                <Input.TextArea
                    rows={4}
                    maxLength={2000}
                    showCount
                    placeholder="Descreva brevemente a causa ou a ação tomada (opcional)."
                    value={resolutionNoteDraft}
                    onChange={(e) => setResolutionNoteDraft(e.target.value)}
                />
            </Modal>
        </>
    );
}