// Chunk configuration service - Used to fetch and validate chunk configuration limits

export interface ChunkConfigLimits {
  maxChunkSize: number;        // Max chunk size (tokens)
  maxOverlapSize: number;      // Max overlap size (tokens)
  minOverlapSize: number;      // Min overlap size (tokens)
  defaultChunkSize: number;    // Default chunk size
  defaultOverlapSize: number;  // Default overlap size
  modelInfo: EmbeddingModelLimit; // Model info
}

export interface EmbeddingModelLimit {
  name: string;              // Model name
  maxInputTokens: number;    // Model input limit
  maxBatchSize: number;      // Model batch limit
  expectedDimensions: number; // Expected vector dimensions
}

export const chunkConfigService = {
  /**
   * Fetch chunk configuration limits
   * @param embeddingModelId Embedding model ID
   * @param authToken Auth token
   * @returns Configuration limit info
   */
  async getLimits(
    embeddingModelId: string,
    authToken: string
  ): Promise<ChunkConfigLimits> {
    const params = new URLSearchParams({
      embeddingModelId,
    });

    const response = await fetch(
      `/api/knowledge-bases/chunk-config/limits?${params.toString()}`,
      {
        method: 'GET',
        headers: {
          'Authorization': `Bearer ${authToken}`,
          'Content-Type': 'application/json',
        },
      }
    );

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(errorData.message || 'loadLimitsFailed');
    }

    return response.json();
  },

  /**
   * Validate if chunk configuration is valid
   * @param chunkSize Chunk size
   * @param chunkOverlap Overlap size
   * @param limits Config limits
   * @returns Validation results and error info
   */
  validateConfig(
    chunkSize: number,
    chunkOverlap: number,
    limits: ChunkConfigLimits
  ): {
    isValid: boolean;
    errors: string[];
    adjustedChunkSize: number;
    adjustedOverlapSize: number;
  } {
    const errors: string[] = [];
    let adjustedChunkSize = chunkSize;
    let adjustedOverlapSize = chunkOverlap;

    // Chunk sizeの検証
    if (chunkSize > limits.maxChunkSize) {
      errors.push(`Chunk size ${chunkSize}  exceeds limit  ${limits.maxChunkSize} `);
      adjustedChunkSize = limits.maxChunkSize;
    }

    if (chunkSize < 50) {
      errors.push(`Chunk size ${chunkSize}  is below minimum  50 `);
      adjustedChunkSize = 50;
    }

    // Overlap sizeの検証
    const maxOverlapByRatio = Math.floor(adjustedChunkSize * 0.5);
    if (chunkOverlap > limits.maxOverlapSize) {
      errors.push(`Overlap size ${chunkOverlap}  exceeds limit  ${limits.maxOverlapSize} `);
      adjustedOverlapSize = limits.maxOverlapSize;
    }

    if (chunkOverlap > maxOverlapByRatio) {
      errors.push(`Overlap size ${chunkOverlap} がChunk sizeの50% (${maxOverlapByRatio}) `);
      adjustedOverlapSize = maxOverlapByRatio;
    }

    if (chunkOverlap < limits.minOverlapSize) {
      adjustedOverlapSize = limits.minOverlapSize;
    }

    return {
      isValid: errors.length === 0,
      errors,
      adjustedChunkSize,
      adjustedOverlapSize,
    };
  },

  /**
   * Format limit info for display
   */
  formatLimits(limits: ChunkConfigLimits): string {
    return [
      `Model: ${limits.modelInfo.name}`,
      `Max Chunk: ${limits.maxChunkSize} tokens`,
      `Max Overlap: ${limits.maxOverlapSize} tokens`,
      `Batch Limit: ${limits.modelInfo.maxBatchSize}`,
      `Vector Dimensions: ${limits.modelInfo.expectedDimensions}`,
    ].join(' | ');
  },
};