turash/bugulma/frontend/services/sites-api.ts

import { reportError } from '@/lib/error-handling';
import { CrudService } from '@/lib/service-base';
import { SERVICE_CONFIGS } from '@/lib/service-config';
import {
  backendSiteSchema,
  createSiteRequestSchema,
  nearbySitesQuerySchema,
  type BackendSite,
  type CreateSiteRequest,
  type NearbySitesQuery,
} from '@/schemas/backend/site';

// Re-export types for use in hooks
export type { CreateSiteRequest, NearbySitesQuery };

/**
 * Sites Service
 * Handles all site-related API operations with improved reliability and type safety
 */
class SitesService extends CrudService<BackendSite, CreateSiteRequest> {
  protected entitySchema = backendSiteSchema;
  protected createSchema = createSiteRequestSchema;
  protected updateSchema = createSiteRequestSchema.partial(); // Allow partial updates

  constructor() {
    super(SERVICE_CONFIGS.SITES);
  }

  /**
   * Get all sites with enhanced error handling
   */
  async getAllSites(): Promise<BackendSite[]> {
    const result = await this.getAll({
      context: 'getAllSites',
      useArrayFallback: true,
    });

    if (!result.success) {
      console.error('[DEBUG] Site validation failed:', result.error);
      // For sites, we prefer to return empty array rather than throw
      this.logError(`Failed to fetch sites: ${result.error?.message}`, result.error);
      return [];
    }

    return result.data;
  }

  /**
   * Get sites by organization ID
   */
  async getSitesByOrganization(organizationId: string): Promise<BackendSite[]> {
    const result = await this.get(`organization/${organizationId}`, this.entitySchema.array(), undefined, {
      context: `getSitesByOrganization(${organizationId})`,
      useArrayFallback: true,
    });

    if (!result.success) {
      // Organizations without sites are valid, so return empty array
      this.log(`No sites found for organization ${organizationId}`);
      return [];
    }

    return result.data;
  }

  /**
   * Get heritage sites (sites with heritage status)
   * @param locale Optional locale code (en, tt, ru). Defaults to ru.
   */
  async getHeritageSites(locale?: string): Promise<BackendSite[]> {
    const params = locale ? { locale } : undefined;
    const result = await this.get('heritage', this.entitySchema.array(), params, {
      context: 'getHeritageSites',
      useArrayFallback: true,
    });

    if (!result.success) {
      this.log(`No heritage sites found`);
      return [];
    }

    return result.data;
  }

  /**
   * Get nearby sites
   */
  async getNearbySites(query: NearbySitesQuery): Promise<BackendSite[]> {
    const validatedQuery = this.validateStrict(nearbySitesQuerySchema, query, 'getNearbySites query');

    const queryParams = {
      lat: validatedQuery.lat.toString(),
      lng: validatedQuery.lng.toString(),
      ...(validatedQuery.radius && { radius: validatedQuery.radius.toString() }),
    };

    const result = await this.get('nearby', this.entitySchema.array(), queryParams, {
      context: 'getNearbySites',
      useArrayFallback: true,
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to fetch nearby sites'),
        { operation: 'getNearbySites', query: validatedQuery }
      );
      throw error;
    }

    return result.data;
  }
}

// Create and export service instance
const sitesService = new SitesService();

// Export service instance for direct usage
export { sitesService };

// Export service methods directly for cleaner imports
export const getSiteById = (id: string) => sitesService.getById(id).then(result => {
  if (!result.success) {
    const error = reportError(
      new Error(result.error?.message || 'Failed to fetch site'),
      { operation: 'getSiteById', id }
    );
    throw error;
  }
  return result.data;
});

export const getAllSites = sitesService.getAllSites.bind(sitesService);
export const getSitesByOrganization = sitesService.getSitesByOrganization.bind(sitesService);
export const getHeritageSites = sitesService.getHeritageSites.bind(sitesService);
export const getNearbySites = sitesService.getNearbySites.bind(sitesService);

export const createSite = (request: CreateSiteRequest) => sitesService.create(request).then(result => {
  if (!result.success) {
    const error = reportError(
      new Error(result.error?.message || 'Failed to create site'),
      { operation: 'createSite', request }
    );
    throw error;
  }
  return result.data;
});

export const deleteSite = (id: string) => sitesService.remove(id).then(result => {
  if (!result.success) {
    const error = reportError(
      new Error(result.error?.message || 'Failed to delete site'),
      { operation: 'deleteSite', id }
    );
    throw error;
  }
});