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

import { z } from 'zod';
import { BaseService } from '@/lib/service-base';
import { reportError } from '@/lib/error-handling';
import { SERVICE_CONFIGS } from '@/lib/service-config';
import type { HistoricalLandmark, OrganizationFormData, WebIntelligenceResult } from '@/types';

/**
 * Backend AI API Client
 * All AI/LLM operations are handled by the backend
 */

// Request/Response schemas
const extractDataFromTextRequestSchema = z.object({
  text: z.string().min(1, 'Text cannot be empty'),
});

const extractDataFromFileRequestSchema = z.object({
  file: z.instanceof(File),
});

const analyzeSymbiosisRequestSchema = z.object({
  organization_id: z.string().min(1, 'Organization ID is required'),
});

const analyzeSymbiosisResponseSchema = z.object({
  matches: z.array(
    z.object({
      partner_id: z.string(),
      partner_name: z.string(),
      reason: z.string(),
      score: z.number().min(0).max(1),
    })
  ),
});

const getWebIntelligenceRequestSchema = z.object({
  organization_name: z.string().min(1, 'Organization name is required'),
});

const getSearchSuggestionsRequestSchema = z.object({
  query: z.string().min(1, 'Query cannot be empty'),
});

const generateOrganizationDescriptionRequestSchema = z.object({
  name: z.string().min(1, 'Name is required'),
  sector_key: z.string().min(1, 'Sector key is required'),
  keywords: z.string().min(1, 'Keywords are required'),
});

const generateHistoricalContextRequestSchema = z.object({
  landmark: z.object({
    id: z.string(),
    name: z.string(),
    period: z.string(),
    originalPurpose: z.string(),
    currentStatus: z.string(),
  }),
});

const sendMessageRequestSchema = z.object({
  message: z.string().min(1, 'Message cannot be empty'),
  system_instruction: z.string().optional(),
});

// Type exports (keeping for backward compatibility)
export interface ExtractDataFromTextRequest {
  text: string;
}

export interface ExtractDataFromFileRequest {
  file: File;
}

export interface AnalyzeSymbiosisRequest {
  organization_id: string;
}

export interface GetWebIntelligenceRequest {
  organization_name: string;
}

export interface GetSearchSuggestionsRequest {
  query: string;
}

export interface GenerateOrganizationDescriptionRequest {
  name: string;
  sector_key: string;
  keywords: string;
}

export interface GenerateHistoricalContextRequest {
  landmark: HistoricalLandmark;
}

export interface SendMessageRequest {
  message: string;
  system_instruction?: string;
}

/**
 * AI Service
 * Handles all AI-related API operations with improved reliability and type safety
 */
class AIService extends BaseService {
  constructor() {
    super(SERVICE_CONFIGS.AI);
  }

  /**
   * Extract structured organization data from text
   */
  async extractDataFromText(
    request: ExtractDataFromTextRequest
  ): Promise<Partial<OrganizationFormData>> {
    const validatedRequest = this.validateStrict(
      extractDataFromTextRequestSchema,
      request,
      'extractDataFromText'
    );

    const formData = new FormData();
    formData.append('text', validatedRequest.text);

    const result = await this.post('extract/text', formData, z.any(), {
      context: 'extractDataFromText',
      isFormData: true,
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to extract data from text'),
        { operation: 'extractDataFromText', textLength: validatedRequest.text.length }
      );
      throw error;
    }

    return result.data;
  }

  /**
   * Extract structured organization data from file
   */
  async extractDataFromFile(
    request: ExtractDataFromFileRequest
  ): Promise<Partial<OrganizationFormData>> {
    const validatedRequest = this.validateStrict(
      extractDataFromFileRequestSchema,
      request,
      'extractDataFromFile'
    );

    const formData = new FormData();
    formData.append('file', validatedRequest.file);

    const result = await this.post('extract/file', formData, z.any(), {
      context: 'extractDataFromFile',
      isFormData: true,
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to extract data from file'),
        {
          operation: 'extractDataFromFile',
          fileName: validatedRequest.file.name,
          fileSize: validatedRequest.file.size,
        }
      );
      throw error;
    }

    return result.data;
  }

  /**
   * Analyze symbiotic relationships
   */
  async analyzeSymbiosis(request: AnalyzeSymbiosisRequest) {
    const validatedRequest = this.validateStrict(
      analyzeSymbiosisRequestSchema,
      request,
      'analyzeSymbiosis'
    );

    const result = await this.post(
      'analyze/symbiosis',
      validatedRequest,
      analyzeSymbiosisResponseSchema,
      {
        context: 'analyzeSymbiosis',
      }
    );

    if (!result.success) {
      const error = reportError(new Error(result.error?.message || 'Failed to analyze symbiosis'), {
        operation: 'analyzeSymbiosis',
        organizationId: validatedRequest.organization_id,
      });
      throw error;
    }

    return result.data;
  }

  /**
   * Get web intelligence
   */
  async getWebIntelligence(request: GetWebIntelligenceRequest): Promise<WebIntelligenceResult> {
    const validatedRequest = this.validateStrict(
      getWebIntelligenceRequestSchema,
      request,
      'getWebIntelligence'
    );

    const result = await this.post('web-intelligence', validatedRequest, z.any(), {
      context: 'getWebIntelligence',
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to get web intelligence'),
        { operation: 'getWebIntelligence', organizationName: validatedRequest.organization_name }
      );
      throw error;
    }

    return result.data;
  }

  /**
   * Get search suggestions
   */
  async getSearchSuggestions(request: GetSearchSuggestionsRequest): Promise<string[]> {
    const validatedRequest = this.validateStrict(
      getSearchSuggestionsRequestSchema,
      request,
      'getSearchSuggestions'
    );

    const result = await this.post('search-suggestions', validatedRequest, z.array(z.string()), {
      context: 'getSearchSuggestions',
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to get search suggestions'),
        { operation: 'getSearchSuggestions', query: validatedRequest.query }
      );
      throw error;
    }

    return result.data;
  }

  /**
   * Generate organization description
   */
  async generateOrganizationDescription(
    request: GenerateOrganizationDescriptionRequest
  ): Promise<string> {
    const validatedRequest = this.validateStrict(
      generateOrganizationDescriptionRequestSchema,
      request,
      'generateOrganizationDescription'
    );

    const result = await this.post('generate/description', validatedRequest, z.string(), {
      context: 'generateOrganizationDescription',
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to generate description'),
        { operation: 'generateOrganizationDescription', name: validatedRequest.name }
      );
      throw error;
    }

    return result.data;
  }

  /**
   * Generate historical context
   */
  async generateHistoricalContext(request: GenerateHistoricalContextRequest): Promise<string> {
    const validatedRequest = this.validateStrict(
      generateHistoricalContextRequestSchema,
      request,
      'generateHistoricalContext'
    );

    const result = await this.post('generate/historical-context', validatedRequest, z.string(), {
      context: 'generateHistoricalContext',
    });

    if (!result.success) {
      const error = reportError(
        new Error(result.error?.message || 'Failed to generate historical context'),
        { operation: 'generateHistoricalContext', landmarkId: validatedRequest.landmark.id }
      );
      throw error;
    }

    return result.data;
  }

  /**
   * Send message to AI
   */
  async sendMessage(request: SendMessageRequest): Promise<string> {
    const validatedRequest = this.validateStrict(sendMessageRequestSchema, request, 'sendMessage');

    const result = await this.post('chat', validatedRequest, z.string(), {
      context: 'sendMessage',
    });

    if (!result.success) {
      const error = reportError(new Error(result.error?.message || 'Failed to send message'), {
        operation: 'sendMessage',
        messageLength: validatedRequest.message.length,
        hasSystemInstruction: !!validatedRequest.system_instruction,
      });
      throw error;
    }

    return result.data;
  }
}

// Create and export service instance
const aiService = new AIService();

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

// Export service methods directly for cleaner imports
export const extractDataFromText = aiService.extractDataFromText.bind(aiService);
export const extractDataFromFile = aiService.extractDataFromFile.bind(aiService);
export const analyzeSymbiosis = aiService.analyzeSymbiosis.bind(aiService);
export const getWebIntelligence = aiService.getWebIntelligence.bind(aiService);
export const getSearchSuggestions = aiService.getSearchSuggestions.bind(aiService);
export const generateOrganizationDescription =
  aiService.generateOrganizationDescription.bind(aiService);
export const generateHistoricalContext = aiService.generateHistoricalContext.bind(aiService);
export const sendMessage = aiService.sendMessage.bind(aiService);