'use client';

import React, { useCallback, useEffect, useState } from 'react';
import { Alert, Button, Space, Tag, Tooltip } from 'antd';
import { Cloud, RefreshCw } from 'lucide-react';
import { ICON_SIZE_MD } from '@/components/icons';
import ContentCard from '@/components/layouts/ContentCard/ContentCard';
import { API_ENDPOINTS } from '@/lib/api/endpoints';
import apiClient from '@/lib/api/client';
import { message } from '@/lib/feedback/message';

interface CloudflareDnsStatusPayload {
    enabled: boolean;
    piloto_activo: boolean;
    code: string;
    message: string;
    credentials_configured?: boolean;
    capabilities?: {
        sync_dns?: boolean;
    };
}

interface CloudflareDnsStatusEnvelope {
    data: CloudflareDnsStatusPayload;
    meta?: {
        stub?: boolean;
        piloto_activa_sync?: boolean;
        adr?: string;
    };
}

interface CloudflareDnsSyncStubSectionProps {
    projetoId: number;
}

/**
 * Seção honesta de sync Cloudflare DNS (TASK-PWP-057 / ADR-0075).
 * Consulta status na API; sync POST → 501 — nunca toast de sucesso.
 */
export function CloudflareDnsSyncStubSection({ projetoId }: CloudflareDnsSyncStubSectionProps) {
    const [statusLoading, setStatusLoading] = useState(true);
    const [syncLoading, setSyncLoading] = useState(false);
    const [status, setStatus] = useState<CloudflareDnsStatusPayload | null>(null);
    const [statusError, setStatusError] = useState<string | null>(null);

    useEffect(() => {
        let cancelled = false;

        async function loadStatus() {
            if (!Number.isFinite(projetoId)) {
                setStatusLoading(false);
                return;
            }

            setStatusLoading(true);
            setStatusError(null);

            try {
                const { data } = await apiClient.get<CloudflareDnsStatusEnvelope>(
                    API_ENDPOINTS.projetos.cloudflareDns.status(projetoId),
                );
                if (!cancelled) {
                    setStatus(data.data);
                }
            } catch {
                if (!cancelled) {
                    setStatus(null);
                    setStatusError(
                        'Não foi possível consultar o estado da integração Cloudflare nesta versão.',
                    );
                }
            } finally {
                if (!cancelled) {
                    setStatusLoading(false);
                }
            }
        }

        void loadStatus();

        return () => {
            cancelled = true;
        };
    }, [projetoId]);

    const handleSync = useCallback(async () => {
        if (!Number.isFinite(projetoId)) {
            return;
        }

        setSyncLoading(true);
        try {
            const { data } = await apiClient.post<{
                message?: string;
                code?: string;
                meta?: { synced?: boolean };
            }>(API_ENDPOINTS.projetos.cloudflareDns.sync(projetoId), { dry_run: true });

            const synced = data.meta?.synced === true;
            if (synced) {
                message.success(data.message ?? 'Sync concluído.');
            } else {
                message.warning(
                    data.message ??
                        'Sync Cloudflare DNS ainda não está disponível nesta versão (stub).',
                );
            }
        } catch (error: unknown) {
            const axiosPayload =
                typeof error === 'object' &&
                error !== null &&
                'response' in error &&
                typeof (error as { response?: { data?: { message?: string } } }).response?.data
                    ?.message === 'string'
                    ? (error as { response: { data: { message: string } } }).response.data.message
                    : null;

            message.warning(
                axiosPayload ??
                    'Sync Cloudflare DNS ainda não está disponível nesta versão (stub).',
            );
        } finally {
            setSyncLoading(false);
        }
    }, [projetoId]);

    const statusMessage =
        status?.message ??
        'A sincronização automática de registros DNS com Cloudflare ainda não está implementada.';

    return (
        <ContentCard title="Sync Cloudflare DNS" style={{ marginTop: 24 }}>
            <Space direction="vertical" size="middle" style={{ width: '100%' }}>
                <Space wrap>
                    <Tag icon={<Cloud size={14} aria-hidden />} color="default">
                        Em breve
                    </Tag>
                    <Tag color="orange">Stub — sem sync real</Tag>
                    {status?.code ? <Tag>{status.code}</Tag> : null}
                </Space>

                <Alert
                    type="warning"
                    showIcon
                    message="Integração Cloudflare em evolução"
                    description={
                        statusError ??
                        (statusLoading
                            ? 'A consultar estado da integração…'
                            : `${statusMessage} Registre DNS manualmente em Hospedagem ou numa ata até haver API Domínios e conector Cloudflare (ADR-0075).`)
                    }
                    data-testid="cloudflare-dns-stub-alert"
                />

                <Tooltip title="Sync automático ainda não disponível — pedido registrado como stub (501)">
                    <Button
                        icon={<RefreshCw size={ICON_SIZE_MD} aria-hidden />}
                        loading={syncLoading}
                        disabled={statusLoading}
                        data-testid="cloudflare-dns-sync-stub"
                        onClick={() => void handleSync()}
                    >
                        Sincronizar DNS (Cloudflare)
                    </Button>
                </Tooltip>
            </Space>
        </ContentCard>
    );
}