import { v4 as uuidv4 } from 'uuid';
import { vehiculosApi } from './api';
import { db } from './db';
import { syncEngine } from './sync-engine';

function isNetworkLikeError(error: any): boolean {
  if (typeof navigator !== 'undefined' && !navigator.onLine) {
    return true;
  }

  const status = Number(error?.status);
  if (Number.isFinite(status) && status >= 500) {
    return true;
  }

  const msg = String(error?.message || '');
  return /Failed to fetch|NetworkError|ERR_EMPTY_RESPONSE|ECONNREFUSED|ECONNRESET|Internal server error/i.test(msg);
}

export function mapRemoteVehiculoToDb(vehiculo: any) {
  const clienteIds = Array.isArray(vehiculo?.clienteIds)
    ? vehiculo.clienteIds.map((id: any) => String(id).trim()).filter(Boolean)
    : [];

  return {
    localId: String(vehiculo.localId || `srv-${vehiculo.id}`),
    serverId: Number(vehiculo.id),
    placa: String(vehiculo.placa || '').toUpperCase(),
    marca: vehiculo.marca || '',
    modelo: vehiculo.modelo || '',
    anio: vehiculo.anio,
    motor: vehiculo.motor || '',
    cilindraje: vehiculo.cilindraje || '',
    color: vehiculo.color || '',
    tipoVehiculoId: Number(vehiculo.tipoVehiculoId || vehiculo.tipoVehiculo?.id || 0),
    clienteId: vehiculo.clienteId || clienteIds[0] || '',
    clienteIds,
    syncStatus: 'synced' as const,
    lastModified: Date.now(),
  };
}

export async function cacheRemoteVehiculos(list: any[]): Promise<void> {
  if (!Array.isArray(list) || list.length === 0) {
    return;
  }

  const mapped = list
    .filter((v) => Number.isFinite(Number(v?.id)))
    .map(mapRemoteVehiculoToDb);

  await db.transaction('rw', db.vehiculos, async () => {
    for (const vehiculo of mapped) {
      const existing = await db.vehiculos.where('serverId').equals(vehiculo.serverId).first();
      if (existing && existing.syncStatus === 'pending') {
        continue;
      }

      await db.vehiculos.put(vehiculo);
    }
  });
}

export async function getLocalVehiculos(
  paramsOrSearch: string | { search?: string; page?: number; limit?: number } = '',
  legacyLimit = 100,
) {
  const params = typeof paramsOrSearch === 'string'
    ? { search: paramsOrSearch, page: 1, limit: legacyLimit }
    : paramsOrSearch;

  const search = params.search || '';
  const page = params.page || 1;
  const limit = params.limit || legacyLimit;
  const normalized = search.trim().toLowerCase();
  const all = await db.vehiculos.toArray();

  const filtered = normalized.length >= 2
    ? all.filter((vehiculo) => {
        const composite = `${vehiculo.placa || ''} ${vehiculo.marca || ''} ${vehiculo.modelo || ''}`.toLowerCase();
        return composite.includes(normalized);
      })
    : all;

  const sorted = filtered.sort((a, b) => (a.placa || '').localeCompare(b.placa || ''));
  const total = sorted.length;
  const safeLimit = Math.max(1, limit);
  const totalPages = Math.max(1, Math.ceil(total / safeLimit));
  const safePage = Math.min(Math.max(1, page), totalPages);
  const start = (safePage - 1) * safeLimit;

  return {
    data: sorted.slice(start, start + safeLimit).map((vehiculo) => ({
      id: vehiculo.serverId || `local-${vehiculo.localId}`,
      localId: vehiculo.localId,
      serverId: vehiculo.serverId,
      placa: vehiculo.placa,
      marca: vehiculo.marca,
      modelo: vehiculo.modelo,
      anio: vehiculo.anio,
      motor: vehiculo.motor,
      cilindraje: vehiculo.cilindraje,
      color: vehiculo.color,
      tipoVehiculoId: vehiculo.tipoVehiculoId,
      clienteId: vehiculo.clienteId,
      clienteIds: vehiculo.clienteIds || (vehiculo.clienteId ? [vehiculo.clienteId] : []),
      syncStatus: vehiculo.syncStatus,
    })),
    total,
    page: safePage,
    limit: safeLimit,
    totalPages,
  };
}

export async function createVehiculoWithOffline(data: any): Promise<any> {
  try {
    const created = await vehiculosApi.create(data);
    await db.vehiculos.put(mapRemoteVehiculoToDb(created));
    return created;
  } catch (error: any) {
    if (!isNetworkLikeError(error)) {
      throw error;
    }

    const localId = uuidv4();

    await db.vehiculos.put({
      localId,
      placa: String(data.placa || '').toUpperCase(),
      marca: data.marca || '',
      modelo: data.modelo || '',
      anio: data.anio,
      motor: data.motor || '',
      cilindraje: data.cilindraje || '',
      color: data.color || '',
      tipoVehiculoId: Number(data.tipoVehiculoId),
      clienteId: data.clienteId || data.clienteIds?.[0] || '',
      clienteIds: data.clienteIds || [],
      syncStatus: 'pending',
      lastModified: Date.now(),
    });

    await syncEngine.queueEvent({
      eventId: crypto.randomUUID(),
      eventType: 'CREATE_VEHICULO',
      entityType: 'vehiculo',
      localId,
      payload: {
        ...data,
        placa: String(data.placa || '').toUpperCase(),
      },
    });

    return {
      id: `local-${localId}`,
      localId,
      placa: String(data.placa || '').toUpperCase(),
      ...data,
      offlineQueued: true,
    };
  }
}