/*
|--------------------------------------------------------------------------
| Agência PSI — Shared hooks: WhatsApp opt-out + auto-reply
|--------------------------------------------------------------------------
| Logica provider-agnostica compartilhada entre evolution-whatsapp-inbound
| e twilio-whatsapp-inbound. Cada provider injeta seu proprio SendFn —
| Evolution envia direto via API (sem deducao de credito), Twilio envolve
| o envio em deducao atomica com rollback.
|
| Schema-per-tenant: tabelas tenant (conversation_*, agenda_regras_semanais)
| são acessadas via `tdb` (client ligado ao schema tenant_<slug>, SEM coluna
| tenant_id). RPCs de crédito (deduct/add_whatsapp_credits) e tenant_members
| são globais → usam `supa` (public) + p_tenant_id explícito.
|--------------------------------------------------------------------------
*/

import type { SupabaseClient } from 'https://esm.sh/@supabase/supabase-js@2'

// Provider deve prover uma funcao de envio de texto puro
export type SendFn = (phone: string, text: string) => Promise<{ ok: boolean; messageId?: string | null; error?: string }>

export type ProviderLabel = 'evolution' | 'twilio'

export function buildThreadKey(patientId: string | null, phone: string | null): string {
    if (patientId) return patientId
    return `anon:${phone ?? 'unknown'}`
}

export function normalizeForMatch(s: string | null | undefined): string {
    return String(s ?? '')
        .toLowerCase()
        .normalize('NFD')
        .replace(/[̀-ͯ]/g, '')
        .replace(/[^\p{L}\p{N}\s]/gu, ' ')
        .replace(/\s+/g, ' ')
        .trim()
}

// ═══════════════════════════════════════════════════════════════════════
// Opt-out (LGPD)  — tabelas tenant via `tdb`
// ═══════════════════════════════════════════════════════════════════════

export async function detectOptoutKeyword(
    tdb: SupabaseClient,
    body: string | null
): Promise<string | null> {
    if (!body) return null
    const normalized = normalizeForMatch(body)
    if (!normalized) return null

    // keywords de sistema + do tenant já vivem no schema do tenant (seed do template)
    const { data } = await tdb
        .from('conversation_optout_keywords')
        .select('keyword')
        .eq('enabled', true)

    if (!data || !data.length) return null

    for (const row of data) {
        const kw = normalizeForMatch(row.keyword)
        if (!kw) continue
        if (normalized === kw) return row.keyword
        const pattern = new RegExp(`(^|\\s)${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\s|$)`)
        if (pattern.test(normalized)) return row.keyword
    }
    return null
}

export async function isOptedOut(tdb: SupabaseClient, phone: string): Promise<boolean> {
    const { data } = await tdb
        .from('conversation_optouts')
        .select('id')
        .eq('phone', phone)
        .is('opted_back_in_at', null)
        .limit(1)
        .maybeSingle()
    return !!data
}

const OPT_IN_KEYWORDS = ['voltar', 'retornar', 'reativar', 'restart']
export async function maybeOptIn(
    tdb: SupabaseClient,
    phone: string,
    body: string | null
): Promise<boolean> {
    if (!body) return false
    const normalized = normalizeForMatch(body)
    if (!normalized) return false
    for (const kw of OPT_IN_KEYWORDS) {
        if (normalized === kw || new RegExp(`(^|\\s)${kw}(\\s|$)`).test(normalized)) {
            const { data } = await tdb
                .from('conversation_optouts')
                .update({ opted_back_in_at: new Date().toISOString() })
                .eq('phone', phone)
                .is('opted_back_in_at', null)
                .select('id')
                .maybeSingle()
            return !!data
        }
    }
    return false
}

export async function registerOptout(
    tdb: SupabaseClient,
    phone: string,
    patientId: string | null,
    originalMessage: string | null,
    keywordMatched: string,
    provider: ProviderLabel,
    sendFn: SendFn
): Promise<void> {
    const { data: existing } = await tdb
        .from('conversation_optouts')
        .select('id')
        .eq('phone', phone)
        .is('opted_back_in_at', null)
        .maybeSingle()

    if (existing) return

    await tdb.from('conversation_optouts').insert({
        phone,
        patient_id: patientId,
        source: 'keyword',
        keyword_matched: keywordMatched,
        original_message: (originalMessage || '').slice(0, 500)
    })

    const ackText = 'OK! Não enviaremos mais mensagens automáticas. Você ainda pode falar com seu terapeuta diretamente quando quiser. Para voltar a receber, envie VOLTAR.'
    try {
        const res = await sendFn(phone, ackText)
        if (res.ok) {
            await tdb.from('conversation_messages').insert({
                patient_id: patientId,
                channel: 'whatsapp',
                direction: 'outbound',
                from_number: null,
                to_number: phone,
                body: ackText,
                provider,
                provider_message_id: res.messageId ?? null,
                provider_raw: { optout_ack: true },
                kanban_status: 'resolved',
                responded_at: new Date().toISOString()
            })
        } else {
            console.error('[optout] ack send failed:', res.error)
        }
    } catch (err) {
        console.error('[optout] ack send error:', err)
    }
}

// ═══════════════════════════════════════════════════════════════════════
// Auto-reply (schedule-aware, cooldown, respeita opt-out)  — via `tdb`
// ═══════════════════════════════════════════════════════════════════════

export type ScheduleWindow = { dow: number; start: string; end: string }

function hhmmToMinutes(s: string): number {
    const m = String(s).match(/^(\d{1,2}):(\d{2})/)
    if (!m) return -1
    return parseInt(m[1], 10) * 60 + parseInt(m[2], 10)
}

function nowInSaoPaulo(): { dow: number; minutes: number } {
    const now = new Date()
    const fmt = new Intl.DateTimeFormat('en-US', {
        timeZone: 'America/Sao_Paulo',
        weekday: 'short',
        hour: '2-digit',
        minute: '2-digit',
        hour12: false
    })
    const parts = fmt.formatToParts(now)
    const weekday = parts.find((p) => p.type === 'weekday')?.value || 'Sun'
    const hour = parseInt(parts.find((p) => p.type === 'hour')?.value || '0', 10)
    const minute = parseInt(parts.find((p) => p.type === 'minute')?.value || '0', 10)
    const dowMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 }
    return { dow: dowMap[weekday] ?? 0, minutes: hour * 60 + minute }
}

function isWithinWindows(windows: ScheduleWindow[]): boolean {
    if (!Array.isArray(windows) || !windows.length) return false
    const { dow, minutes } = nowInSaoPaulo()
    for (const w of windows) {
        if (w.dow !== dow) continue
        const start = hhmmToMinutes(w.start)
        const end = hhmmToMinutes(w.end)
        if (start < 0 || end < 0) continue
        if (minutes >= start && minutes < end) return true
    }
    return false
}

async function windowsFromAgenda(tdb: SupabaseClient): Promise<ScheduleWindow[]> {
    const { data, error } = await tdb
        .from('agenda_regras_semanais')
        .select('dia_semana, hora_inicio, hora_fim, ativo')
        .eq('ativo', true)
    if (error || !data) return []
    return data.map((r) => ({
        dow: r.dia_semana,
        start: String(r.hora_inicio).slice(0, 5),
        end: String(r.hora_fim).slice(0, 5)
    }))
}

export async function maybeSendAutoReply(
    tdb: SupabaseClient,
    threadKey: string,
    fromPhone: string | null,
    provider: ProviderLabel,
    sendFn: SendFn
): Promise<{ sent: boolean; reason?: string }> {
    if (!fromPhone) return { sent: false, reason: 'no_phone' }

    if (await isOptedOut(tdb, fromPhone)) {
        return { sent: false, reason: 'opted_out' }
    }

    const { data: settings } = await tdb
        .from('conversation_autoreply_settings')
        .select('enabled, message, cooldown_minutes, schedule_mode, business_hours, custom_window')
        .maybeSingle()

    if (!settings || !settings.enabled) return { sent: false, reason: 'disabled' }

    let withinHours = false
    if (settings.schedule_mode === 'agenda') {
        const windows = await windowsFromAgenda(tdb)
        withinHours = isWithinWindows(windows)
    } else if (settings.schedule_mode === 'business_hours') {
        withinHours = isWithinWindows((settings.business_hours as ScheduleWindow[]) || [])
    } else if (settings.schedule_mode === 'custom') {
        withinHours = isWithinWindows((settings.custom_window as ScheduleWindow[]) || [])
    }

    if (withinHours) return { sent: false, reason: 'within_hours' }

    if ((settings.cooldown_minutes ?? 0) > 0) {
        const cutoff = new Date(Date.now() - settings.cooldown_minutes * 60 * 1000).toISOString()
        const { data: recent } = await tdb
            .from('conversation_autoreply_log')
            .select('sent_at')
            .eq('thread_key', threadKey)
            .gte('sent_at', cutoff)
            .order('sent_at', { ascending: false })
            .limit(1)
            .maybeSingle()
        if (recent) return { sent: false, reason: 'cooldown' }
    }

    const sendRes = await sendFn(fromPhone, settings.message)
    if (!sendRes.ok) {
        console.error('[auto-reply] send failed:', sendRes.error)
        return { sent: false, reason: 'send_failed' }
    }

    await tdb.from('conversation_messages').insert({
        channel: 'whatsapp',
        direction: 'outbound',
        from_number: null,
        to_number: fromPhone,
        body: settings.message,
        provider,
        provider_message_id: sendRes.messageId ?? null,
        provider_raw: { auto_reply: true },
        kanban_status: 'awaiting_patient',
        responded_at: new Date().toISOString()
    })

    await tdb.from('conversation_autoreply_log').insert({
        thread_key: threadKey
    })

    return { sent: true }
}

// ═══════════════════════════════════════════════════════════════════════
// Twilio: send wrapper com deducao de credito + rollback
// Créditos são GLOBAIS (addon) → RPC via `supa` (public) + p_tenant_id.
// ═══════════════════════════════════════════════════════════════════════

export type TwilioChannel = {
    twilio_subaccount_sid: string
    twilio_phone_number: string
    credentials: { subaccount_auth_token?: string }
}

async function sendViaTwilioRaw(
    channel: TwilioChannel,
    toPhone: string,
    text: string
): Promise<{ ok: boolean; messageId?: string; error?: string }> {
    const subSid = channel.twilio_subaccount_sid
    const authToken = channel.credentials?.subaccount_auth_token
    const fromNumber = channel.twilio_phone_number
    if (!subSid || !authToken || !fromNumber) {
        return { ok: false, error: 'Twilio credenciais incompletas' }
    }
    const endpoint = `https://api.twilio.com/2010-04-01/Accounts/${subSid}/Messages.json`
    const basicAuth = btoa(`${subSid}:${authToken}`)
    const toE164 = toPhone.startsWith('+') ? toPhone : `+${toPhone}`
    const params = new URLSearchParams()
    params.append('From', `whatsapp:${fromNumber}`)
    params.append('To', `whatsapp:${toE164}`)
    params.append('Body', text)

    try {
        const resp = await fetch(endpoint, {
            method: 'POST',
            headers: { Authorization: `Basic ${basicAuth}`, 'Content-Type': 'application/x-www-form-urlencoded' },
            body: params.toString()
        })
        const data = await resp.json().catch(() => null) as Record<string, unknown> | null
        if (!resp.ok) {
            return { ok: false, error: `Twilio ${resp.status}: ${(data?.message as string) || ''}` }
        }
        return { ok: true, messageId: String(data?.sid || '') }
    } catch (e) {
        return { ok: false, error: String(e) }
    }
}

// Cria SendFn que:
// 1) deduz 1 credito do tenant via RPC atomica (GLOBAL)
// 2) envia via Twilio; se falhar, refunda o credito
// 3) retorna resultado ao caller
export function makeTwilioCreditedSendFn(
    supa: SupabaseClient,
    tenantId: string,
    channel: TwilioChannel,
    noteLabel: string
): SendFn {
    return async (phone: string, text: string) => {
        const { error: dedErr } = await supa.rpc('deduct_whatsapp_credits', {
            p_tenant_id: tenantId,
            p_amount: 1,
            p_conversation_message_id: null,
            p_note: noteLabel
        })
        if (dedErr) {
            const insufficient = String(dedErr.message || '').includes('insufficient_credits')
            return { ok: false, error: insufficient ? 'insufficient_credits' : dedErr.message }
        }

        const sendRes = await sendViaTwilioRaw(channel, phone, text)
        if (!sendRes.ok) {
            await supa.rpc('add_whatsapp_credits', {
                p_tenant_id: tenantId,
                p_amount: 1,
                p_kind: 'refund',
                p_purchase_id: null,
                p_admin_id: null,
                p_note: `Refund ${noteLabel}: ${(sendRes.error || '').slice(0, 180)}`
            })
            return { ok: false, error: sendRes.error }
        }
        return { ok: true, messageId: sendRes.messageId ?? null }
    }
}


// ════════════════════════════════════════════════════════════════════════════
// Bot de auto-triagem (3.7)
// Tabelas conversation_* via `tdb`; pickAnyAdmin (tenant_members) via `supa`.
// ════════════════════════════════════════════════════════════════════════════

type BotStep = { prompt: string; variable: string; type?: string }
type BotConfig = {
    enabled: boolean
    greeting_message: string
    closing_message: string
    steps: BotStep[]
    trigger_mode: 'new_contact' | 'all_unassigned' | 'keyword'
    trigger_keywords: string[]
    idle_timeout_minutes: number
    respect_optout: boolean
}

/**
 * Verifica se o bot deve processar esta inbound. Se sim, avança/inicia
 * a sessão e envia a próxima pergunta. Retorna true se processou (caller
 * deve skipar auto-reply pra não empilhar respostas).
 *
 * Caller garante que esta função só é chamada quando:
 *   - mensagem é inbound (não fromMe)
 *   - não é opt-out
 */
export async function maybeProcessBot(
    tdb: SupabaseClient,
    supa: SupabaseClient,
    tenantId: string,
    threadKey: string,
    patientId: string | null,
    phone: string,
    body: string,
    sendFn: SendFn
): Promise<{ processed: boolean; status?: string; step?: number; reason?: string }> {
    const text = String(body || '').trim()

    // Carrega config
    const { data: cfg } = await tdb
        .from('conversation_bots')
        .select('*')
        .maybeSingle()

    if (!cfg || !cfg.enabled) return { processed: false, reason: 'disabled' }
    const config = cfg as BotConfig
    if (!Array.isArray(config.steps) || config.steps.length === 0) {
        return { processed: false, reason: 'no_steps' }
    }

    // Busca sessão ativa
    const { data: active } = await tdb
        .from('conversation_bot_sessions')
        .select('*')
        .eq('thread_key', threadKey)
        .eq('status', 'active')
        .maybeSingle()

    if (active) {
        // Se humano já atribuiu a thread, abandona bot
        const { data: assign } = await tdb
            .from('conversation_assignments')
            .select('assigned_to')
            .eq('thread_key', threadKey)
            .maybeSingle()
        if (assign?.assigned_to) {
            await tdb.from('conversation_bot_sessions')
                .update({ status: 'abandoned_manual', abandoned_at: new Date().toISOString() })
                .eq('id', active.id)
            return { processed: false, reason: 'human_took_over' }
        }

        return await advanceSession(tdb, supa, tenantId, config, active, text, phone, sendFn)
    }

    // Sem sessão ativa — decide se inicia
    if (config.trigger_mode === 'new_contact') {
        // Inicia só se ainda não existe nenhuma sessão (completada ou abandonada) pra essa thread
        const { data: prev } = await tdb
            .from('conversation_bot_sessions')
            .select('id')
            .eq('thread_key', threadKey)
            .limit(1)
            .maybeSingle()
        if (prev) return { processed: false, reason: 'already_bot_history' }
        // Também pula se paciente já existe (é contato conhecido)
        if (patientId) return { processed: false, reason: 'known_patient' }
    } else if (config.trigger_mode === 'keyword') {
        const normalized = normalizeForMatch(text)
        const matched = (config.trigger_keywords || []).some((kw) => normalized.includes(normalizeForMatch(kw)))
        if (!matched) return { processed: false, reason: 'no_keyword_match' }
    }
    // 'all_unassigned' passa direto

    // Inicia nova sessão
    return await startSession(tdb, config, threadKey, phone, sendFn)
}

async function startSession(
    tdb: SupabaseClient,
    config: BotConfig,
    threadKey: string,
    phone: string,
    sendFn: SendFn
): Promise<{ processed: boolean; status?: string; step?: number }> {
    const { data: session, error: sessErr } = await tdb
        .from('conversation_bot_sessions')
        .insert({
            thread_key: threadKey,
            contact_number: phone,
            current_step: 0,
            collected_data: {},
            status: 'active'
        })
        .select('id')
        .single()

    if (sessErr || !session) return { processed: false }

    // Manda greeting + primeira pergunta como 2 mensagens separadas
    const firstPrompt = config.steps[0]?.prompt || ''
    await sendFn(phone, config.greeting_message)
    if (firstPrompt) await sendFn(phone, firstPrompt)

    return { processed: true, status: 'started', step: 0 }
}

async function advanceSession(
    tdb: SupabaseClient,
    supa: SupabaseClient,
    tenantId: string,
    config: BotConfig,
    session: { id: string, current_step: number, collected_data: Record<string, unknown>, thread_key: string, contact_number: string | null },
    text: string,
    phone: string,
    sendFn: SendFn
): Promise<{ processed: boolean; status?: string; step?: number }> {
    const step = Number(session.current_step) || 0
    const currentStep = config.steps[step]
    if (!currentStep) {
        // Segurança: step fora do range → encerra
        await tdb.from('conversation_bot_sessions')
            .update({ status: 'completed', completed_at: new Date().toISOString() })
            .eq('id', session.id)
        return { processed: true, status: 'completed', step }
    }

    // Salva resposta do step atual
    const newData = { ...(session.collected_data || {}), [currentStep.variable]: text }
    const nextStep = step + 1
    const isLast = nextStep >= config.steps.length

    if (isLast) {
        // Finaliza
        await tdb.from('conversation_bot_sessions')
            .update({
                collected_data: newData,
                current_step: nextStep,
                status: 'completed',
                completed_at: new Date().toISOString(),
                last_advance_at: new Date().toISOString()
            })
            .eq('id', session.id)

        // Envia closing
        if (config.closing_message) await sendFn(phone, config.closing_message)

        // Cria nota interna com resumo
        try {
            const lines = config.steps.map((s) => {
                const val = newData[s.variable] ?? '—'
                return `• ${s.variable}: ${val}`
            })
            const summary = `🤖 Triagem automática concluída:\n\n${lines.join('\n')}`
            await tdb.from('conversation_notes').insert({
                thread_key: session.thread_key,
                contact_number: session.contact_number,
                body: summary,
                // created_by obrigatório — usa qualquer admin do tenant (tenant_members é global)
                created_by: await pickAnyAdmin(supa, tenantId)
            })
        } catch (err) {
            console.warn('[bot] failed to create summary note:', (err as Error)?.message)
        }

        return { processed: true, status: 'completed', step: nextStep }
    }

    // Avança pra próxima pergunta
    await tdb.from('conversation_bot_sessions')
        .update({
            collected_data: newData,
            current_step: nextStep,
            last_advance_at: new Date().toISOString()
        })
        .eq('id', session.id)

    const nextPrompt = config.steps[nextStep]?.prompt || ''
    if (nextPrompt) await sendFn(phone, nextPrompt)

    return { processed: true, status: 'advanced', step: nextStep }
}

async function pickAnyAdmin(supa: SupabaseClient, tenantId: string): Promise<string> {
    const { data } = await supa
        .from('tenant_members')
        .select('user_id')
        .eq('tenant_id', tenantId)
        .in('role', ['tenant_admin', 'clinic_admin'])
        .eq('status', 'active')
        .limit(1)
        .maybeSingle()
    return (data?.user_id as string) ?? '00000000-0000-0000-0000-000000000000'
}
