/*
 * useMelissaPacientes — composable que carrega pacientes ativos do terapeuta
 * --------------------------------------------------
 * Pattern espelhado de `src/features/patients/PatientsListPage.vue`:
 *   - withOwnerFilter (apenas os pacientes do owner_id = uid do user logado)
 *   - withTenantFilter (defesa em profundidade — RLS cobre, mas blindamos no client)
 *   - normalizeStatus client-side (DB pode ter 'ativo'/'active'/null/etc.)
 *
 * Sem auth (sem uid ou tenant), retorna vazio sem erro — permite a pagina
 * renderizar mesmo sem session (defesa em profundidade).
 *
 * Forma normalizada do paciente:
 *   { id, nome, email, telefone, avatar_url, status, last_attended_at, created_at }
 *
 * Quando precisar fora do Melissa: promover pra src/composables/.
 */
import { ref, onMounted } from 'vue';
import { supabase } from '@/lib/supabase/client';
import { tenantDb } from '@/lib/supabase/tenantClient';
import { useTenantStore } from '@/stores/tenantStore';
import { useMelissaCacheStore, MELISSA_CACHE_TTL } from '@/stores/melissaCacheStore';

// Mesma lógica da PatientsListPage.vue — DB pode ter valores variados
function normalizeStatus(s) {
    const v = String(s || '').toLowerCase().trim();
    if (!v) return 'Ativo';
    if (v === 'active' || v === 'ativo') return 'Ativo';
    if (v === 'inactive' || v === 'inativo') return 'Inativo';
    return v.charAt(0).toUpperCase() + v.slice(1);
}

/**
 * @param {object} [opts]
 * @param {boolean} [opts.onlyActive=true]
 *   true (default, legado) = retorna só status='Ativo' (uso original: cards do
 *   resumo, cronômetro, eventos hoje — só faz sentido com ativos).
 *   false = retorna todos (Ativo + Inativo + Arquivado), pra páginas que
 *   precisam mostrar/filtrar por status (ex.: MelissaPacientes).
 */
export function useMelissaPacientes(opts = {}) {
    const onlyActive = opts.onlyActive !== false; // default true (compat)
    const autoFetch  = opts.autoFetch !== false;  // default true (compat)
    const tenantStore = useTenantStore();
    const cache = useMelissaCacheStore();

    const pacientes = ref([]);
    const loading = ref(false);
    const error = ref(null);
    const uid = ref(null);

    async function ensureUid() {
        if (uid.value) return uid.value;
        // Fast path: session do storage local (<10ms vs ~80ms do getUser)
        const { data: ses } = await supabase.auth.getSession();
        if (ses?.session?.user?.id) {
            uid.value = ses.session.user.id;
            return uid.value;
        }
        const { data, error: err } = await supabase.auth.getUser();
        if (err) return null;
        uid.value = data?.user?.id || null;
        return uid.value;
    }

    async function _doFetch(userId, tid, cacheKey) {
        const { data, error: err } = await tenantDb().from('patients')
            .select('id, nome_completo, email_principal, telefone, status, avatar_url, last_attended_at, created_at, data_nascimento')
            .eq('owner_id', userId)
            
            .order('nome_completo', { ascending: true })
            .limit(1000);

        if (err) throw err;

        const todos = (data || []).map((r) => ({
            id: r.id,
            nome: r.nome_completo || '',
            email: r.email_principal || '',
            telefone: r.telefone || '',
            avatar_url: r.avatar_url || null,
            status: normalizeStatus(r.status),
            last_attended_at: r.last_attended_at || null,
            created_at: r.created_at || null,
            data_nascimento: r.data_nascimento || null
        }));

        const finalList = onlyActive ? todos.filter((p) => p.status === 'Ativo') : todos;
        cache.set('pacientesTimeline', finalList, cacheKey);
        pacientes.value = finalList;
        return finalList;
    }

    // useCache=true (boot/auto): hidrata do cache se válido + revalida em background.
    // useCache=false (refetch após mutation): força query nova, descarta cache.
    async function _fetch({ useCache = true } = {}) {
        const userId = await ensureUid();
        if (typeof tenantStore.ensureLoaded === 'function') {
            await tenantStore.ensureLoaded();
        }
        const tid = tenantStore.activeTenantId || tenantStore.tenantId || null;

        if (!userId || !tid) {
            pacientes.value = [];
            return;
        }

        const cacheKey = `${userId}:${tid}:${onlyActive ? 'a' : 'all'}`;

        if (useCache) {
            const cached = cache.get('pacientesTimeline', cacheKey, MELISSA_CACHE_TTL.pacientesTimeline);
            if (cached) {
                pacientes.value = cached;
                _doFetch(userId, tid, cacheKey).catch((e) => {
                    // eslint-disable-next-line no-console
                    console.warn('[useMelissaPacientes] revalidate', e);
                });
                return;
            }
        } else {
            // Force: invalida o slot pra outras instâncias (se houver) também
            // pegarem fresh na próxima leitura.
            cache.invalidate('pacientesTimeline');
        }

        loading.value = true;
        error.value = null;
        try {
            await _doFetch(userId, tid, cacheKey);
        } catch (e) {
            error.value = e?.message || 'Erro ao carregar pacientes';
            pacientes.value = [];
            // eslint-disable-next-line no-console
            console.warn('[useMelissaPacientes]', e);
        } finally {
            loading.value = false;
        }
    }

    if (autoFetch) onMounted(() => _fetch({ useCache: true }));

    return {
        pacientes,
        loading,
        error,
        // refetch força query nova (uso em handlers pós-mutation: criar/editar/deletar).
        refetch: () => _fetch({ useCache: false }),
        // fetchCached usa stale-while-revalidate (uso em defer/idle callback).
        fetchCached: () => _fetch({ useCache: true })
    };
}
