/*
|--------------------------------------------------------------------------
| Agência PSI
|--------------------------------------------------------------------------
| Criado e desenvolvido por Leonardo Nohama
|
| Tecnologia aplicada à escuta.
| Estrutura para o cuidado.
|
| Arquivo: src/features/agenda/composables/useServices.js
| Data: 2026
| Local: São Carlos/SP — Brasil
|--------------------------------------------------------------------------
| © 2026 — Todos os direitos reservados
|--------------------------------------------------------------------------
*/
// Interface pública:
//   services            – ref([])   todos os serviços do owner (ativos e inativos)
//   loading             – ref(false)
//   error               – ref('')
//
//   load(ownerId)       – carrega todos os serviços (ativos e inativos)
//   save(payload)       – cria ou atualiza
//   toggle(id, active)  – alterna active
//   remove(id)          – DELETE definitivo
//   getDefaultPrice()   – preço do primeiro serviço ativo, ou null
//   getPriceFor(id)     – preço de um serviço específico, ou null

import { ref } from 'vue';
import { supabase } from '@/lib/supabase/client';

import { tenantDb } from '@/lib/supabase/tenantClient';
export function useServices() {
    const services = ref([]);
    const loading = ref(false);
    const error = ref('');

    async function load(ownerId) {
        if (!ownerId) return;
        loading.value = true;
        error.value = '';
        try {
            const { data, error: err } = await tenantDb().from('services').select('id, name, description, price, duration_min, active').eq('owner_id', ownerId).order('created_at', { ascending: true });

            if (err) throw err;
            services.value = data || [];
        } catch (e) {
            error.value = e?.message || 'Falha ao carregar serviços.';
            services.value = [];
        } finally {
            loading.value = false;
        }
    }

    async function save(payload) {
        error.value = '';
        try {
            const name = payload.name?.trim();
            if (!name) throw new Error('Nome do serviço é obrigatório.');
            if (!payload.owner_id) throw new Error('Owner ausente.');

            // Nome unico por owner (case-insensitive). No update,
            // ignora o proprio id pra nao conflitar consigo mesmo
            // quando o usuario salva sem mudar o nome.
            let dupQuery = tenantDb().from('services').select('id').eq('owner_id', payload.owner_id).ilike('name', name).limit(1);
            if (payload.id) dupQuery = dupQuery.neq('id', payload.id);
            const { data: dups, error: dupErr } = await dupQuery;
            if (dupErr) throw dupErr;
            if (dups && dups.length > 0) {
                throw new Error('Já existe um serviço com este nome.');
            }

            if (payload.id) {
                const { id, owner_id, tenant_id, ...fields } = payload;
                const { error: err } = await tenantDb().from('services').update(fields).eq('id', id).eq('owner_id', owner_id);
                if (err) throw err;
            } else {
                // eslint-disable-next-line no-unused-vars
                const { tenant_id: _dropTenantId, ...insertFields } = payload;
                const { error: err } = await tenantDb().from('services').insert(insertFields);
                if (err) throw err;
            }
        } catch (e) {
            error.value = e?.message || 'Falha ao salvar serviço.';
            throw e;
        }
    }

    async function toggle(id, active) {
        error.value = '';
        try {
            const { error: err } = await tenantDb().from('services').update({ active }).eq('id', id);
            if (err) throw err;
            const svc = services.value.find((s) => s.id === id);
            if (svc) svc.active = active;
        } catch (e) {
            error.value = e?.message || 'Falha ao atualizar serviço.';
            throw e;
        }
    }

    async function remove(id) {
        error.value = '';
        try {
            const { error: err } = await tenantDb().from('services').delete().eq('id', id);
            if (err) throw err;
            services.value = services.value.filter((s) => s.id !== id);
        } catch (e) {
            const msg = String(e?.message || '');
            if (msg.includes('commitment_services_service_id_fkey') || msg.includes('violates foreign key constraint')) {
                error.value = 'Este serviço está vinculado a sessões e não pode ser removido. Use Desativar para ocultá-lo.';
            } else {
                error.value = e?.message || 'Falha ao remover serviço.';
            }
            throw e;
        }
    }

    function getDefaultPrice(serviceId) {
        if (serviceId) {
            const svc = services.value.find((s) => s.id === serviceId);
            return svc?.price != null ? Number(svc.price) : null;
        }
        const first = services.value.find((s) => s.active);
        return first?.price != null ? Number(first.price) : null;
    }

    function getPriceFor(serviceId) {
        return getDefaultPrice(serviceId);
    }

    return { services, loading, error, load, save, toggle, remove, getDefaultPrice, getPriceFor };
}
