import type { PageServerLoad } from './$types';
import { getAuthTokens, authenticatedFetch } from '$lib/server/api';

export const load: PageServerLoad = async ({ cookies, fetch, url, parent }) => {
    const parentData = await parent();
    const { accessToken } = getAuthTokens(cookies);

    if (!accessToken) {
        return { error: 'No authenticated', equivalencies: { items: [], total: 0, page: 1, page_size: 50, pages: 0 } };
    }

    try {
        const page = Number(url.searchParams.get('page')) || 1;
        const pageSize = Number(url.searchParams.get('pageSize')) || 50;
        
        // Obtener company_id de la cookie o usar el primero disponible
        const cookieCompanyId = cookies.get('active_company_id');
        const companyId = cookieCompanyId 
            ? parseInt(cookieCompanyId)
            : parentData.companies?.[0]?.id;

        if (!companyId) {
            return { error: 'No company selected', equivalencies: { items: [], total: 0, page: 1, page_size: 50, pages: 0 } };
        }

        const filters: Record<string, string> = {};
        // El backend usa `from_unit_code` para filtrar por `Equivalency.identifier`
        const fromUnitCode = url.searchParams.get('from_unit_code');
        if (fromUnitCode) filters.from_unit_code = fromUnitCode;

        const queryParams = new URLSearchParams({ 
            page: page.toString(), 
            page_size: pageSize.toString(), 
            company_id: companyId.toString(),
            ...filters 
        });
        
        const response = await authenticatedFetch(
            `v1/a76/equivalencies/?${queryParams.toString()}`,
            { method: 'GET' },
            cookies,
            fetch
        );

        if (!response.ok) {
            let errorMessage = 'Failed to load';
            try {
                const errorData = await response.json();
                errorMessage = errorData.detail || errorData.message || errorMessage;
            } catch (e) {
                // Silently fail if not JSON
            }
            return { error: errorMessage, status: response.status, equivalencies: { items: [], total: 0, page, page_size: pageSize, pages: 0 } };
        }

        const data = await response.json();
        
        // Calculate pages if not present
        if (data.pages === undefined && data.total !== undefined && data.page_size !== undefined) {
             data.pages = Math.ceil(data.total / data.page_size);
        }

        return { equivalencies: data, status: 200 };
    } catch (error: any) {
        console.error('Error loading equivalencies:', error);
        return { 
            error: error.message || 'Error loading', 
            status: error.status || 500,
            equivalencies: { items: [], total: 0, page: 1, page_size: 50, pages: 0 } 
        };
    }
};
