import type { AuthUser, CampaignPreview, CampaignProcessSummary, CampaignQueueSummary, ClientAnalyticsItem, ClientDetailsAnalytics, ClientFilterOptions, ClientMetadataFilters, ClientPurchasePatternAnalytics, CreateUserResult, CuttingSettings, DashboardAnalytics, DateRange, ManagedUser, OrderData, ProductAnalyticsItem, ProductDetailsAnalytics, ProductionOrderSummary, RfmAnalytics, StockData } from './types';
import { formatDateParam } from './dateRanges';

const API_URL = import.meta.env.VITE_API_URL || '/api';
const ANALYTICS_CACHE_TTL_MS = 5 * 60 * 1000;
const IN_FLIGHT_CACHE_TTL_MS = 15 * 1000;

type CacheOptions = {
    force?: boolean;
    shouldCache?: (data: unknown) => boolean;
};

type ApiCacheEntry<T> = {
    expiresAt: number;
    data?: T;
    promise?: Promise<T>;
};

const analyticsCache = new Map<string, ApiCacheEntry<unknown>>();

const getCachedAnalyticsValue = <T>(key: string): T | undefined => {
    const entry = analyticsCache.get(key) as ApiCacheEntry<T> | undefined;
    if (!entry || entry.data === undefined || entry.expiresAt <= Date.now()) return undefined;
    return entry.data;
};

const getCachedAnalytics = async <T>(key: string, loader: () => Promise<T>, options: CacheOptions = {}): Promise<T> => {
    const now = Date.now();
    const cached = analyticsCache.get(key) as ApiCacheEntry<T> | undefined;

    if (!options.force) {
        if (cached?.data !== undefined && cached.expiresAt > now) return cached.data;
        if (cached?.promise && cached.expiresAt > now) return cached.promise;
    }

    const promise = loader();
    analyticsCache.set(key, { expiresAt: now + IN_FLIGHT_CACHE_TTL_MS, promise });

    try {
        const data = await promise;
        if (data === null || options.shouldCache?.(data) === false) {
            analyticsCache.delete(key);
        } else {
            analyticsCache.set(key, { data, expiresAt: Date.now() + ANALYTICS_CACHE_TTL_MS });
        }
        return data;
    } catch (error) {
        analyticsCache.delete(key);
        throw error;
    }
};

const buildDateRangeParams = (dateRange: DateRange) => new URLSearchParams({
    start: formatDateParam(dateRange.start),
    end: formatDateParam(dateRange.end)
});

export const login = async (email: string, password: string): Promise<boolean> => {
  try {
    const response = await fetch(`${API_URL}/login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email, password }),
    });

    if (response.ok) {
      const data = await response.json() as { token?: string; user?: AuthUser };
      if (!data.token || !data.user) return false;
      localStorage.setItem('auth_token', data.token);
      localStorage.setItem('auth_user', JSON.stringify(data.user));
      return true;
    }
    return false;
  } catch (error) {
    console.error('Login failed', error);
    return false;
  }
};

export const logout = () => {
  localStorage.removeItem('auth_token');
  localStorage.removeItem('auth_user');
  window.location.href = '/#/login';
};

export const isAuthenticated = (): boolean => {
  return !!localStorage.getItem('auth_token');
};

export const getCurrentUser = (): AuthUser | null => {
  const rawUser = localStorage.getItem('auth_user');
  if (!rawUser) return null;

  try {
    return JSON.parse(rawUser) as AuthUser;
  } catch {
    localStorage.removeItem('auth_user');
    return null;
  }
};

export const isSuperAdmin = (): boolean => {
  return getCurrentUser()?.role === 'super_admin';
};

export const fetchStock = async (): Promise<StockData[]> => {
    try {
        const token = localStorage.getItem('auth_token');
        const response = await fetch(`${API_URL}/stock`, {
            headers: {
                'Authorization': `Bearer ${token}`
            }
        });
        if (response.status === 401 || response.status === 403) {
            logout();
            return [];
        }
        if (!response.ok) return [];
        return await response.json();
    } catch {
        return [];
    }
};

export const fetchData = async (): Promise<OrderData[]> => {
    try {
        const token = localStorage.getItem('auth_token');
        const response = await fetch(`${API_URL}/data`, {
            headers: {
                'Authorization': `Bearer ${token}`
            }
        });
        if (response.status === 401 || response.status === 403) {
            logout();
            return [];
        }
        if (!response.ok) return [];
        return await response.json();
    } catch (error) {
        console.error("Fetch failed", error);
        return [];
    }
};

const authFetch = async (path: string, options: RequestInit = {}): Promise<Response> => {
    const token = localStorage.getItem('auth_token');
    const response = await fetch(`${API_URL}${path}`, {
        ...options,
        headers: {
            ...(options.headers || {}),
            'Authorization': `Bearer ${token}`
        }
    });

    if (response.status === 401 || response.status === 403) {
        logout();
    }

    return response;
};

export const fetchProductionOrders = async (
    dateRange: DateRange,
    filters?: { search?: string },
    options?: CacheOptions
): Promise<ProductionOrderSummary> => {
    const params = buildDateRangeParams(dateRange);
    const search = filters?.search?.trim();
    if (search) params.set('search', search);

    const path = `/production-orders?${params.toString()}`;
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path, options?.force ? { cache: 'no-store' } : {});
            if (!response.ok) return { orders: [], counts: { all: 0, open: 0, in_progress: 0, finished: 0, canceled: 0 } };
            return await response.json();
        } catch (error) {
            console.error('Fetch production orders failed', error);
            return { orders: [], counts: { all: 0, open: 0, in_progress: 0, finished: 0, canceled: 0 } };
        }
    }, options);
};

export const fetchCuttingSettings = async (): Promise<CuttingSettings> => {
    try {
        const response = await authFetch('/cutting-settings');
        if (!response.ok) return { familyYields: {}, productOverrides: {} };
        return await response.json();
    } catch (error) {
        console.error('Fetch cutting settings failed', error);
        return { familyYields: {}, productOverrides: {} };
    }
};

export const saveCuttingSettings = async (settings: CuttingSettings): Promise<CuttingSettings> => {
    const response = await authFetch('/cutting-settings', {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(settings)
    });

    const data = await response.json().catch(() => null);
    if (!response.ok) {
        throw new Error(data?.error || 'Não foi possível salvar as regras de corte.');
    }

    return data as CuttingSettings;
};

export const fetchDashboardAnalytics = async (dateRange: DateRange, options?: CacheOptions): Promise<DashboardAnalytics | null> => {
    const path = `/analytics/dashboard?${buildDateRangeParams(dateRange).toString()}`;
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path, options?.force ? { cache: 'no-store' } : {});
            if (!response.ok) return null;
            return await response.json();
        } catch (error) {
            console.error('Fetch dashboard analytics failed', error);
            return null;
        }
    }, {
        ...options,
        shouldCache: (data) => {
            const metrics = data as DashboardAnalytics | null;
            return Boolean(
                metrics &&
                Array.isArray(metrics.revenueBySeller) &&
                Array.isArray(metrics.ordersBySeller) &&
                Array.isArray(metrics.sellerRevenueByDate) &&
                Array.isArray(metrics.sellerRevenueByHour)
            );
        }
    });
};

export const fetchProductAnalytics = async (dateRange: DateRange): Promise<ProductAnalyticsItem[]> => {
    const path = `/analytics/products?${buildDateRangeParams(dateRange).toString()}`;
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path);
            if (!response.ok) return [];
            return await response.json();
        } catch (error) {
            console.error('Fetch product analytics failed', error);
            return [];
        }
    });
};

export const fetchProductDetailsAnalytics = async (productId: string, dateRange: DateRange): Promise<ProductDetailsAnalytics | null> => {
    const path = `/analytics/products/${encodeURIComponent(productId)}/details?${buildDateRangeParams(dateRange).toString()}`;
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path);
            if (!response.ok) return null;
            return await response.json();
        } catch (error) {
            console.error('Fetch product details analytics failed', error);
            return null;
        }
    });
};

const appendClientMetadataFilterParams = (params: URLSearchParams, filters?: Partial<ClientMetadataFilters>) => {
    if (!filters) return;
    if (filters.marketplace) params.set('marketplace', filters.marketplace);
    if (filters.canal_venda) params.set('canal_venda', filters.canal_venda);
    if (filters.seller) params.set('seller', filters.seller);
};

const hasClientFilterOptions = (data: unknown) => {
    const options = data as ClientFilterOptions | null;
    return Boolean(
        options?.marketplaces?.length ||
        options?.salesChannels?.length ||
        options?.sellers?.length
    );
};

export const fetchClientFilterOptions = async (dateRange: DateRange, options?: CacheOptions): Promise<ClientFilterOptions> => {
    const path = `/analytics/clients/filters?${buildDateRangeParams(dateRange).toString()}`;
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path, options?.force ? { cache: 'no-store' } : {});
            if (!response.ok) return { marketplaces: [], salesChannels: [], sellers: [] };
            return await response.json();
        } catch (error) {
            console.error('Fetch client filter options failed', error);
            return { marketplaces: [], salesChannels: [], sellers: [] };
        }
    }, {
        ...options,
        shouldCache: hasClientFilterOptions
    });
};

const buildRfmAnalyticsPath = (dateRange: DateRange, filters?: Partial<ClientMetadataFilters>) => {
    const params = buildDateRangeParams(dateRange);
    appendClientMetadataFilterParams(params, filters);
    return `/analytics/rfm?${params.toString()}`;
};

export const getCachedRfmAnalytics = (dateRange: DateRange, filters?: Partial<ClientMetadataFilters>): RfmAnalytics | undefined => {
    return getCachedAnalyticsValue<RfmAnalytics>(buildRfmAnalyticsPath(dateRange, filters));
};

export const fetchRfmAnalytics = async (dateRange: DateRange, filters?: Partial<ClientMetadataFilters>, options?: CacheOptions): Promise<RfmAnalytics | null> => {
    const path = buildRfmAnalyticsPath(dateRange, filters);
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path);
            if (!response.ok) return null;
            return await response.json();
        } catch (error) {
            console.error('Fetch RFM analytics failed', error);
            return null;
        }
    }, options);
};

const buildClientAnalyticsPath = (dateRange: DateRange, filters?: Partial<ClientMetadataFilters>) => {
    const params = buildDateRangeParams(dateRange);
    appendClientMetadataFilterParams(params, filters);
    return `/analytics/clients?${params.toString()}`;
};

export const getCachedClientAnalytics = (dateRange: DateRange, filters?: Partial<ClientMetadataFilters>): ClientAnalyticsItem[] | undefined => {
    return getCachedAnalyticsValue<ClientAnalyticsItem[]>(buildClientAnalyticsPath(dateRange, filters));
};

export const getCachedClientFilterOptions = (dateRange: DateRange): ClientFilterOptions | undefined => {
    return getCachedAnalyticsValue<ClientFilterOptions>(`/analytics/clients/filters?${buildDateRangeParams(dateRange).toString()}`);
};

export const fetchClientAnalytics = async (dateRange: DateRange, filters?: Partial<ClientMetadataFilters>, options?: CacheOptions): Promise<ClientAnalyticsItem[]> => {
    const path = buildClientAnalyticsPath(dateRange, filters);
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path);
            if (!response.ok) return [];
            return await response.json();
        } catch (error) {
            console.error('Fetch client analytics failed', error);
            return [];
        }
    }, options);
};

const emptyClientPurchasePattern = (): ClientPurchasePatternAnalytics => ({
    weekdayRangeLabel: 'Todo período',
    hourRangeLabel: 'Últimos 60 dias',
    purchaseWeekdays: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab'].map(label => ({ label, value: 0 })),
    purchaseHours: Array.from({ length: 24 }, (_, hour) => ({
        label: `${String(hour).padStart(2, '0')}h`,
        value: 0
    }))
});

export const fetchClientPurchasePatternAnalytics = async (options?: CacheOptions): Promise<ClientPurchasePatternAnalytics> => {
    const path = '/analytics/clients/purchase-pattern';
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path, options?.force ? { cache: 'no-store' } : {});
            if (!response.ok) return emptyClientPurchasePattern();
            return await response.json();
        } catch (error) {
            console.error('Fetch client purchase pattern analytics failed', error);
            return emptyClientPurchasePattern();
        }
    }, options);
};

export const fetchClientDetailsAnalytics = async (clientToken: string, dateRange: DateRange): Promise<ClientDetailsAnalytics | null> => {
    const path = `/analytics/clients/${encodeURIComponent(clientToken)}/details?${buildDateRangeParams(dateRange).toString()}`;
    return getCachedAnalytics(path, async () => {
        try {
            const response = await authFetch(path);
            if (!response.ok) return null;
            return await response.json();
        } catch (error) {
            console.error('Fetch client details analytics failed', error);
            return null;
        }
    });
};

export const clearAnalyticsCache = () => {
    analyticsCache.clear();
};

export const fetchCampaigns = async (): Promise<CampaignQueueSummary | null> => {
    try {
        const response = await authFetch('/campaigns');
        if (!response.ok) return null;
        return await response.json();
    } catch (error) {
        console.error('Fetch campaigns failed', error);
        return null;
    }
};

export const fetchCampaignPreview = async (): Promise<CampaignPreview | null> => {
    try {
        const response = await authFetch('/campaigns/preview');
        if (!response.ok) return null;
        return await response.json();
    } catch (error) {
        console.error('Fetch campaign preview failed', error);
        return null;
    }
};

export const processCampaignsNow = async (): Promise<CampaignProcessSummary | null> => {
    try {
        const response = await authFetch('/campaigns/process', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({})
        });
        if (!response.ok) return null;
        return await response.json();
    } catch (error) {
        console.error('Process campaigns failed', error);
        return null;
    }
};

export const retryCampaignGroup = async (baseProductName: string): Promise<boolean> => {
    try {
        const response = await authFetch('/campaigns/retry', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ baseProductName })
        });
        return response.ok;
    } catch (error) {
        console.error('Retry campaign failed', error);
        return false;
    }
};

export const fetchUsers = async (): Promise<ManagedUser[]> => {
    try {
        const response = await authFetch('/users');
        if (!response.ok) return [];
        const data = await response.json() as { users?: ManagedUser[] };
        return data.users || [];
    } catch (error) {
        console.error('Fetch users failed', error);
        return [];
    }
};

export const createUser = async (payload: { name: string; email: string; password?: string }): Promise<CreateUserResult> => {
    const response = await authFetch('/users', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload)
    });

    const data = await response.json().catch(() => null);
    if (!response.ok) {
        throw new Error(data?.error || 'Não foi possível criar o usuário.');
    }

    return data as CreateUserResult;
};

export const updateUser = async (id: number, payload: { name: string; email: string; isActive: boolean; password?: string }): Promise<ManagedUser> => {
    const response = await authFetch(`/users/${id}`, {
        method: 'PATCH',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload)
    });

    const data = await response.json().catch(() => null);
    if (!response.ok) {
        throw new Error(data?.error || 'Não foi possível editar o usuário.');
    }

    return data.user as ManagedUser;
};

export const deleteUser = async (id: number): Promise<void> => {
    const response = await authFetch(`/users/${id}`, {
        method: 'DELETE'
    });

    if (!response.ok) {
        const data = await response.json().catch(() => null);
        throw new Error(data?.error || 'Não foi possível excluir o usuário.');
    }
};

export const exportToCSV = (data: Record<string, unknown>[], filename: string) => {
  if (!data || !data.length) return;
  
  const headers = Object.keys(data[0]);
  const csvRows = [];
  
  // Add headers
  csvRows.push(headers.join(','));
  
  // Add rows
  for (const row of data) {
    const values = headers.map(header => {
      const val = row[header];
      const escaped = String(val ?? '').replace(/"/g, '""');
      return `"${escaped}"`;
    });
    csvRows.push(values.join(','));
  }
  
  const csvString = csvRows.join('\n');
  const blob = new Blob([csvString], { type: 'text/csv;charset=utf-8;' });
  const link = document.createElement('a');
  if (link.download !== undefined) {
    const url = URL.createObjectURL(blob);
    link.setAttribute('href', url);
    link.setAttribute('download', filename);
    link.style.visibility = 'hidden';
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
  }
};