// frontend/src/api/services/training.service.ts
/**
 * Training Service
 * Handles ML model training operations
 */

import { apiClient } from '../client';
import { RequestTimeouts } from '../client/config';
import type {
  TrainingJobRequest,
  TrainingJobResponse,
  SingleProductTrainingRequest,
  ModelInfo,
  ModelTrainingStats,
  PaginatedResponse,
  BaseQueryParams,
} from '../types';

export class TrainingService {
  /**
   * Start Training Job for All Products
   */
  async startTrainingJob(
    tenantId: string,
    request: TrainingJobRequest
  ): Promise<TrainingJobResponse> {
    return apiClient.post(
      `/tenants/${tenantId}/training/jobs`,
      request,
      {
        timeout: RequestTimeouts.EXTENDED,
      }
    );
  }

  /**
   * Start Training for Single Product
   */
  async startSingleProductTraining(
    tenantId: string,
    request: SingleProductTrainingRequest
  ): Promise<TrainingJobResponse> {
    return apiClient.post(
      `/tenants/${tenantId}/training/single`,
      request,
      {
        timeout: RequestTimeouts.EXTENDED,
      }
    );
  }

  /**
   * Get Training Job Status
   */
  async getTrainingJobStatus(tenantId: string, jobId: string): Promise<TrainingJobResponse> {
    return apiClient.get(`/tenants/${tenantId}/training/jobs/${jobId}/status`);
  }

  /**
   * Get Training Job Logs
   */
  async getTrainingJobLogs(tenantId: string, jobId: string): Promise<{ logs: string[] }> {
    return apiClient.get(`/tenants/${tenantId}/training/jobs/${jobId}/logs`);
  }

  /**
   * Cancel Training Job
   */
  async cancelTrainingJob(tenantId: string, jobId: string): Promise<{ message: string }> {
    return apiClient.post(`/tenants/${tenantId}/training/jobs/${jobId}/cancel`);
  }

  /**
   * Get Training Jobs
   */
  async getTrainingJobs(
    tenantId: string,
    params?: BaseQueryParams & {
      status?: string;
      start_date?: string;
      end_date?: string;
    }
  ): Promise<PaginatedResponse<TrainingJobResponse>> {
    return apiClient.get(`/tenants/${tenantId}/training/jobs`, { params });
  }

  /**
   * Validate Data for Training
   */
  async validateTrainingData(tenantId: string): Promise<{
    is_valid: boolean;
    message: string;
    details?: any;
  }> {
    return apiClient.post(`/tenants/${tenantId}/training/validate`);
  }

  /**
   * Get Trained Models
   */
  async getModels(
    tenantId: string,
    params?: BaseQueryParams & {
      inventory_product_id?: string;  // Primary way to filter by product
      product_name?: string;  // For backward compatibility - will need inventory service lookup
      is_active?: boolean;
    }
  ): Promise<PaginatedResponse<ModelInfo>> {
    return apiClient.get(`/tenants/${tenantId}/models`, { params });
  }

  /**
   * Get Model Details
   */
  async getModel(tenantId: string, modelId: string): Promise<ModelInfo> {
    return apiClient.get(`/tenants/${tenantId}/models/${modelId}`);
  }

  /**
   * Update Model Status
   */
  async updateModelStatus(
    tenantId: string,
    modelId: string,
    isActive: boolean
  ): Promise<ModelInfo> {
    return apiClient.patch(`/tenants/${tenantId}/models/${modelId}`, {
      is_active: isActive,
    });
  }

  /**
   * Delete Model
   */
  async deleteModel(tenantId: string, modelId: string): Promise<{ message: string }> {
    return apiClient.delete(`/tenants/${tenantId}/models/${modelId}`);
  }

  /**
   * Get Training Statistics
   */
  async getTrainingStats(tenantId: string): Promise<ModelTrainingStats> {
    return apiClient.get(`/tenants/${tenantId}/training/stats`);
  }

  /**
   * Download Model File
   */
  async downloadModel(tenantId: string, modelId: string): Promise<Blob> {
    const response = await apiClient.request(`/tenants/${tenantId}/models/${modelId}/download`, {
      method: 'GET',
      headers: {
        'Accept': 'application/octet-stream',
      },
    });

    return new Blob([response]);
  }
}

export const trainingService = new TrainingService();