import { Injectable, Logger, Inject, forwardRef } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { ChatOpenAI } from '@langchain/openai';
import { PromptTemplate } from '@langchain/core/prompts';
import { ElasticsearchService } from '../elasticsearch/elasticsearch.service';
import { EmbeddingService } from '../knowledge-base/embedding.service';
import { ModelConfigService } from '../model-config/model-config.service';
import { KnowledgeGroupService } from '../knowledge-group/knowledge-group.service';
import { SearchHistoryService } from '../search-history/search-history.service';
import { ModelConfig, ModelType } from '../types';
import { RagService } from '../rag/rag.service';

import {
  DEFAULT_VECTOR_DIMENSIONS,
  DEFAULT_LANGUAGE,
} from '../common/constants';
import { I18nService } from '../i18n/i18n.service';
import { TenantService } from '../tenant/tenant.service';
import { UserSettingService } from '../user/user-setting.service';

export interface ChatMessage {
  role: 'user' | 'assistant';
  content: string;
}

@Injectable()
export class ChatService {
  private readonly logger = new Logger(ChatService.name);
  private readonly defaultDimensions: number;

  constructor(
    @Inject(forwardRef(() => ElasticsearchService))
    private elasticsearchService: ElasticsearchService,
    private embeddingService: EmbeddingService,
    private modelConfigService: ModelConfigService,
    @Inject(forwardRef(() => KnowledgeGroupService))
    private knowledgeGroupService: KnowledgeGroupService,
    private searchHistoryService: SearchHistoryService,
    private configService: ConfigService,
    private ragService: RagService,
    private i18nService: I18nService,
    private tenantService: TenantService,
    private userSettingService: UserSettingService,
  ) {
    this.defaultDimensions = parseInt(
      this.configService.get<string>(
        'DEFAULT_VECTOR_DIMENSIONS',
        String(DEFAULT_VECTOR_DIMENSIONS),
      ),
    );
  }

  async *streamChat(
    message: string,
    history: ChatMessage[],
    userId: string,
    modelConfig: ModelConfig,
    userLanguage: string = DEFAULT_LANGUAGE,
    selectedEmbeddingId?: string,
    selectedGroups?: string[], // New: Selected groups
    selectedFiles?: string[], // New: Selected files
    historyId?: string, // New: Chat history ID
    enableRerank: boolean = false,
    selectedRerankId?: string,
    temperature?: number, // New: temperature parameter
    maxTokens?: number, // New: maxTokens parameter
    topK?: number, // New: topK parameter
    similarityThreshold?: number, // New: similarityThreshold parameter
    rerankSimilarityThreshold?: number, // New: rerankSimilarityThreshold parameter
    enableQueryExpansion?: boolean, // New
    enableHyDE?: boolean, // New
    tenantId?: string, // New: tenant isolation
  ): AsyncGenerator<{ type: 'content' | 'sources' | 'historyId'; data: any }> {
    this.logger.log('=== ChatService.streamChat ===');
    this.logger.log('User ID:', userId);
    this.logger.log('User language:', userLanguage);
    this.logger.log('Selected embedding model ID:', selectedEmbeddingId);
    this.logger.log('Selected groups:', selectedGroups);
    this.logger.log('Selected files:', selectedFiles);
    this.logger.log('History ID:', historyId);
    this.logger.log('Temperature:', temperature);
    this.logger.log('Max Tokens:', maxTokens);
    this.logger.log('Top K:', topK);
    this.logger.log('Similarity threshold:', similarityThreshold);
    this.logger.log('Rerank threshold:', rerankSimilarityThreshold);
    this.logger.log('Query expansion:', enableQueryExpansion);
    this.logger.log('HyDE:', enableHyDE);
    this.logger.log('Model configuration:', {
      name: modelConfig.name,
      modelId: modelConfig.modelId,
      baseUrl: modelConfig.baseUrl,
    });
    this.logger.log(
      'API Key prefix:',
      modelConfig.apiKey?.substring(0, 10) + '...',
    );
    this.logger.log('API Key length:', modelConfig.apiKey?.length);

    // Get current language setting (keeping LANGUAGE_CONFIG for backward compatibility, now uses i18n service)
    // Use actual language based on user settings
    const effectiveUserLanguage = userLanguage || DEFAULT_LANGUAGE;

    let currentHistoryId = historyId;
    let fullResponse = '';

    try {
      // Create new chat history if no historyId
      if (!currentHistoryId) {
        const searchHistory = await this.searchHistoryService.create(
          userId,
          tenantId || 'default', // New
          message,
          selectedGroups,
        );
        currentHistoryId = searchHistory.id;
        this.logger.log(
          this.i18nService.getMessage(
            'creatingHistory',
            effectiveUserLanguage,
          ) + currentHistoryId,
        );
        yield { type: 'historyId', data: currentHistoryId };
      }

      // Save user message
      await this.searchHistoryService.addMessage(
        currentHistoryId,
        'user',
        message,
      );
      // 1. Get user's embedding model settings
      let embeddingModel: any;

      if (selectedEmbeddingId) {
        // Find specifically selected model
        embeddingModel =
          await this.modelConfigService.findOne(selectedEmbeddingId);
      } else {
        // Use organization's default from Index Chat Config (strict)
        embeddingModel = await this.modelConfigService.findDefaultByType(
          tenantId || 'default',
          ModelType.EMBEDDING,
        );
      }

      this.logger.log(
        this.i18nService.getMessage(
          'usingEmbeddingModel',
          effectiveUserLanguage,
        ) +
          embeddingModel.name +
          ' ' +
          embeddingModel.modelId +
          ' ID:' +
          embeddingModel.id,
      );

      // 2. Search using user's query directly
      this.logger.log(
        this.i18nService.getMessage('startingSearch', effectiveUserLanguage),
      );
      yield {
        type: 'content',
        data:
          this.i18nService.getMessage('searching', effectiveUserLanguage) +
          '\n',
      };

      let searchResults: any[] = [];
      let context = '';

      try {
        // 3. If knowledge groups are selected, get file IDs from those groups first
        let effectiveFileIds = selectedFiles; // Prioritize explicitly specified files
        if (!effectiveFileIds && selectedGroups && selectedGroups.length > 0) {
          // Get file IDs from knowledge groups
          effectiveFileIds =
            await this.knowledgeGroupService.getFileIdsByGroups(
              selectedGroups,
              userId,
              tenantId as string,
            );
        }

        // 3. Use RagService for search (supports hybrid search + Rerank)
        const ragResults = await this.ragService.searchKnowledge(
          message,
          userId,
          topK,
          similarityThreshold,
          embeddingModel.id,
          true, // enableFullTextSearch (Chat defaults to hybrid)
          enableRerank,
          selectedRerankId,
          undefined, // selectedGroups
          effectiveFileIds,
          rerankSimilarityThreshold,
          tenantId,
          enableQueryExpansion,
          enableHyDE,
        );

        // Convert RagSearchResult to format needed by ChatService (any[])
        // HybridSearch returns ES hit structure, but RagSearchResult is normalized
        // BuildContext expects {fileName, content}. RagSearchResult has these
        searchResults = ragResults;
        this.logger.log(
          this.i18nService.getMessage(
            'searchResultsCount',
            effectiveUserLanguage,
          ) + searchResults.length,
        );

        // 4. Build context
        context = this.buildContext(searchResults, effectiveUserLanguage);

        if (searchResults.length === 0) {
          if (selectedGroups && selectedGroups.length > 0) {
            // User selected knowledge groups but no matches found
            const noMatchMsg = this.i18nService.getMessage(
              'noMatchInKnowledgeGroup',
              effectiveUserLanguage,
            );
            yield { type: 'content', data: `⚠️ ${noMatchMsg}\n\n` };
          } else {
            yield {
              type: 'content',
              data:
                this.i18nService.getMessage(
                  'noResults',
                  effectiveUserLanguage,
                ) + '\n\n',
            };
          }
          yield {
            type: 'content',
            data: `[Debug] ${this.i18nService.getMessage('searchScope', effectiveUserLanguage)}: ${selectedFiles ? selectedFiles.length + ' ' + this.i18nService.getMessage('files', effectiveUserLanguage) : selectedGroups ? selectedGroups.length + ' ' + this.i18nService.getMessage('notebooks', effectiveUserLanguage) : this.i18nService.getMessage('all', effectiveUserLanguage)}\n`,
          };
          yield {
            type: 'content',
            data: `[Debug] ${this.i18nService.getMessage('searchResults', effectiveUserLanguage)}: 0 ${this.i18nService.getMessage('items', effectiveUserLanguage)}\n`,
          };
        } else {
          yield {
            type: 'content',
            data: `${searchResults.length} ${this.i18nService.getMessage('relevantInfoFound', effectiveUserLanguage)}。${this.i18nService.getMessage('generatingResponse', effectiveUserLanguage)}...\n\n`,
          };
          // Debug info
          const scores = searchResults
            .map((r) => {
              if (
                r.originalScore !== undefined &&
                r.originalScore !== r.score
              ) {
                return `${r.originalScore.toFixed(2)} → ${r.score.toFixed(2)}`;
              }
              return r.score.toFixed(2);
            })
            .join(', ');
          const files = [...new Set(searchResults.map((r) => r.fileName))].join(
            ', ',
          );
          yield {
            type: 'content',
            data: `> [Debug] ${this.i18nService.getMessage('searchHits', effectiveUserLanguage)}: ${searchResults.length} ${this.i18nService.getMessage('items', effectiveUserLanguage)}\n`,
          };
          yield {
            type: 'content',
            data: `> [Debug] ${this.i18nService.getMessage('relevance', effectiveUserLanguage)}: ${scores}\n`,
          };
          yield {
            type: 'content',
            data: `> [Debug] ${this.i18nService.getMessage('sourceFiles', effectiveUserLanguage)}: ${files}\n\n---\n\n`,
          };
        }
      } catch (searchError) {
        this.logger.error(
          this.i18nService.getMessage(
            'searchFailedLog',
            effectiveUserLanguage,
          ) + ':',
          searchError,
        );
        yield {
          type: 'content',
          data:
            this.i18nService.getMessage('searchFailed', effectiveUserLanguage) +
            '\n\n',
        };
      }

      // 5. Stream response generation
      this.logger.log(
        this.i18nService.formatMessage(
          'modelCall',
          {
            type: 'LLM',
            model: `${modelConfig.name} (${modelConfig.modelId})`,
            user: userId,
          },
          effectiveUserLanguage,
        ),
      );
      const llm = new ChatOpenAI({
        apiKey: modelConfig.apiKey || 'ollama',
        streaming: true,
        temperature: temperature !== undefined ? temperature : 0.3,
        maxTokens: maxTokens !== undefined ? maxTokens : undefined,
        modelName: modelConfig.modelId,
        configuration: {
          baseURL: modelConfig.baseUrl || 'http://localhost:11434/v1',
        },
      });

      const promptTemplate =
        context.length > 0
          ? this.i18nService.getPrompt(
              effectiveUserLanguage,
              'withContext',
              selectedGroups && selectedGroups.length > 0,
            )
          : this.i18nService.getPrompt(effectiveUserLanguage, 'withoutContext');

      const prompt = PromptTemplate.fromTemplate(promptTemplate);

      const chain = prompt.pipe(llm);

      const stream = await chain.stream({
        context,
        history: this.formatHistory(history, userLanguage),
        question: message,
      });

      for await (const chunk of stream) {
        if (chunk.content) {
          fullResponse += chunk.content;
          yield { type: 'content', data: chunk.content };
        }
      }

      // Save AI response
      await this.searchHistoryService.addMessage(
        currentHistoryId,
        'assistant',
        fullResponse,
        searchResults.map((result) => ({
          fileName: result.fileName,
          title: result.metadata?.title || result.metadata?.originalName, // ES metadata contains these
          content: String(result.content).substring(0, 200) + '...',
          score: result.score,
          chunkIndex: result.chunkIndex,
          fileId: result.fileId,
        })),
      );

      // 7. Auto-generate chat title (executed after first exchange)
      const messagesInHistory = await this.searchHistoryService.findOne(
        currentHistoryId,
        userId,
        tenantId,
      );
      if (messagesInHistory.messages.length === 2) {
        this.generateChatTitle(currentHistoryId, userId, tenantId).catch(
          (err) => {
            this.logger.error(
              `Failed to generate chat title for ${currentHistoryId}`,
              err,
            );
          },
        );
      }

      // 6. Return sources
      yield {
        type: 'sources',
        data: searchResults.map((result) => ({
          fileName: result.fileName,
          content: String(result.content).substring(0, 200) + '...',
          score: result.score,
          chunkIndex: result.chunkIndex,
          fileId: result.fileId,
        })),
      };
    } catch (error) {
      this.logger.error(
        this.i18nService.getMessage('chatStreamError', effectiveUserLanguage),
        error,
      );
      yield {
        type: 'content',
        data: `${this.i18nService.getMessage('error', effectiveUserLanguage)}: ${error.message}`,
      };
    }
  }

  async *streamAssist(
    instruction: string,
    context: string,
    modelConfig: ModelConfig,
    userLanguage: string = DEFAULT_LANGUAGE,
  ): AsyncGenerator<{ type: 'content'; data: any }> {
    try {
      this.logger.log(
        this.i18nService.formatMessage(
          'modelCall',
          {
            type: 'LLM (Assist)',
            model: `${modelConfig.name} (${modelConfig.modelId})`,
            user: 'N/A',
          },
          userLanguage,
        ),
      );
      const llm = new ChatOpenAI({
        apiKey: modelConfig.apiKey || 'ollama',
        streaming: true,
        temperature: 0.7,
        modelName: modelConfig.modelId,
        configuration: {
          baseURL: modelConfig.baseUrl || 'http://localhost:11434/v1',
        },
      });

      const systemPrompt = `${this.i18nService.getMessage('intelligentAssistant', userLanguage)}
${this.i18nService.getMessage('assistSystemPrompt', userLanguage)}

${this.i18nService.getMessage('contextLabel', userLanguage)}:
${context}

${this.i18nService.getMessage('userInstructionLabel', userLanguage)}:
${instruction}`;

      const stream = await llm.stream(systemPrompt);

      for await (const chunk of stream) {
        if (chunk.content) {
          yield { type: 'content', data: chunk.content };
        }
      }
    } catch (error) {
      this.logger.error(
        this.i18nService.getMessage('assistStreamError', userLanguage),
        error,
      );
      yield {
        type: 'content',
        data: `${this.i18nService.getMessage('error', userLanguage)}: ${error.message}`,
      };
    }
  }

  private async hybridSearch(
    keywords: string[],
    userId: string,
    embeddingModelId?: string,
    selectedGroups?: string[], // New parameter
    explicitFileIds?: string[], // New parameter
    tenantId?: string, // Added
    userLanguage: string = DEFAULT_LANGUAGE,
  ): Promise<any[]> {
    try {
      // Join keywords into search string
      const combinedQuery = keywords.join(' ');
      this.logger.log(
        this.i18nService.getMessage('searchString', userLanguage) +
          combinedQuery,
      );

      // Check if embedding model ID is provided
      if (!embeddingModelId) {
        this.logger.log(
          this.i18nService.getMessage(
            'embeddingModelIdNotProvided',
            userLanguage,
          ),
        );
        return [];
      }

      // Use actual embedding vector
      this.logger.log(
        this.i18nService.getMessage('generatingEmbeddings', userLanguage),
      );
      const queryEmbedding = await this.embeddingService.getEmbeddings(
        [combinedQuery],
        embeddingModelId,
      );
      const queryVector = queryEmbedding[0];
      this.logger.log(
        this.i18nService.getMessage('embeddingsGenerated', userLanguage) +
          this.i18nService.getMessage('dimensions', userLanguage) +
          ':',
        queryVector.length,
      );

      // Hybrid search
      this.logger.log(
        this.i18nService.getMessage('performingHybridSearch', userLanguage),
      );
      const results = await this.elasticsearchService.hybridSearch(
        queryVector,
        combinedQuery,
        userId,
        10,
        0.6,
        selectedGroups, // Pass selected groups
        explicitFileIds, // Pass explicit file IDs
        tenantId, // Pass tenant ID
      );
      this.logger.log(
        this.i18nService.getMessage('esSearchCompleted', userLanguage) +
          this.i18nService.getMessage('resultsCount', userLanguage) +
          ':',
        results.length,
      );

      return results.slice(0, 10);
    } catch (error) {
      this.logger.error(
        this.i18nService.getMessage('hybridSearchFailed', userLanguage) + ':',
        error,
      );
      return [];
    }
  }

  private buildContext(
    results: any[],
    language: string = DEFAULT_LANGUAGE,
  ): string {
    return results
      .map(
        (result, index) =>
          `[${index + 1}] ${this.i18nService.getMessage('file', language)}：${result.fileName}\n${this.i18nService.getMessage('content', language)}：${result.content}\n`,
      )
      .join('\n');
  }

  private formatHistory(
    history: ChatMessage[],
    userLanguage: string = DEFAULT_LANGUAGE,
  ): string {
    const userLabel = this.i18nService.getMessage('userLabel', userLanguage);
    const assistantLabel = this.i18nService.getMessage(
      'assistantLabel',
      userLanguage,
    );

    return history
      .slice(-6)
      .map(
        (msg) =>
          `${msg.role === 'user' ? userLabel : assistantLabel}：${msg.content}`,
      )
      .join('\n');
  }
  async getContextForTopic(
    topic: string,
    userId: string,
    tenantId?: string,
    groupId?: string,
    fileIds?: string[],
    userLanguage: string = DEFAULT_LANGUAGE,
  ): Promise<string> {
    try {
      // Use organization's default embedding from Index Chat Config (strict)
      const embeddingModel = await this.modelConfigService.findDefaultByType(
        tenantId || 'default',
        ModelType.EMBEDDING,
      );

      const results = await this.hybridSearch(
        [topic],
        userId,
        embeddingModel.id,
        groupId ? [groupId] : undefined,
        fileIds,
        tenantId,
        userLanguage,
      );

      return this.buildContext(results);
    } catch (err) {
      this.logger.error(
        `${this.i18nService.getMessage('getContextForTopicFailed', userLanguage)}: ${err.message}`,
      );
      return '';
    }
  }

  async generateSimpleChat(
    messages: ChatMessage[],
    userId: string,
    tenantId?: string,
    modelConfig?: ModelConfig, // Optional, looks up if not provided
    userLanguage: string = DEFAULT_LANGUAGE,
  ): Promise<string> {
    try {
      let config = modelConfig;
      if (!config) {
        // Use organization's default LLM from Index Chat Config (strict)
        const found = await this.modelConfigService.findDefaultByType(
          tenantId || 'default',
          ModelType.LLM,
        );
        config = found as unknown as ModelConfig;
      }

      this.logger.log(
        this.i18nService.formatMessage(
          'modelCall',
          {
            type: 'LLM (Simple)',
            model: `${config.name} (${config.modelId})`,
            user: userId,
          },
          DEFAULT_LANGUAGE,
        ),
      );
      const settings = await this.tenantService.getSettings(
        tenantId || 'default',
      );
      const llm = new ChatOpenAI({
        apiKey: config.apiKey || 'ollama',
        temperature: settings?.temperature ?? 0.7,
        modelName: config.modelId,
        configuration: {
          baseURL: config.baseUrl || 'http://localhost:11434/v1',
        },
      });

      const response = await llm.invoke(
        messages.map((m) => [m.role, m.content]),
      );

      return String(response.content);
    } catch (error) {
      this.logger.error(
        this.i18nService.getMessage('simpleChatGenerationError', userLanguage),
        error,
      );
      throw error;
    }
  }

  /**
   * Automatically generate chat title based on conversation content
   */
  async generateChatTitle(
    historyId: string,
    userId: string,
    tenantId?: string,
  ): Promise<string | null> {
    this.logger.log(`Generating automatic title for chat session ${historyId}`);

    try {
      const history = await this.searchHistoryService.findOne(
        historyId,
        userId,
        tenantId || 'default',
      );
      if (!history || history.messages.length < 2) {
        return null;
      }

      const userMessage =
        history.messages.find((m) => m.role === 'user')?.content || '';
      const aiResponse =
        history.messages.find((m) => m.role === 'assistant')?.content || '';

      if (!userMessage || !aiResponse) {
        return null;
      }

      // Get language from user settings
      const userSettings = await this.userSettingService.getByUser(userId);
      const language = userSettings?.language || DEFAULT_LANGUAGE;

      // Build prompt
      const prompt = this.i18nService.getChatTitlePrompt(
        language,
        userMessage,
        aiResponse,
      );

      // Call LLM to generate title
      const generatedTitle = await this.generateSimpleChat(
        [{ role: 'user', content: prompt }],
        userId,
        tenantId || 'default',
      );

      if (generatedTitle && generatedTitle.trim().length > 0) {
        // Remove extra quotes
        const cleanedTitle = generatedTitle
          .trim()
          .replace(/^["']|["']$/g, '')
          .substring(0, 50);
        await this.searchHistoryService.updateTitle(historyId, cleanedTitle);
        this.logger.log(
          `Successfully generated title for chat ${historyId}: ${cleanedTitle}`,
        );
        return cleanedTitle;
      }
    } catch (error) {
      this.logger.error(
        `Failed to generate chat title for ${historyId}`,
        error,
      );
    }

    return null;
  }
}