from pathlib import Path
from dataclasses import dataclass
from typing import List, Tuple, Optional
import faiss
import numpy as np
import ollama
import readfiles

@dataclass(frozen=True)
class Config:
  """
  システム全体で使用する定数を管理するクラス
  frozen=Trueにすることで、実行中に設定値が誤って書き換えられるのを防ぐ
  """
  # 埋め込みベクトルの生成に使用する言語モデル
  EMBED_MODEL: str = "paraphrase-multilingual"  
  # 回答生成に使用するLLM
  LLM_MODEL: str = "gpt-oss:20b"      
  # 読み込み対象のフォルダー名  
  DATA_DIRNAME: str = "data"          
  # 検索結果のフィルタリングしきい値
  # 最高スコアの60％未満のチャンクは除外する
  SIMILARITY_THRESHOLD_RATIO: float = 0.6 

@dataclass
class RagChunk:
  """
  検索対象となるチャンクを保持するデータクラス
  """
  content: str            # チャンクの本文
  filename: str           # 出典ファイル名
  embedding: np.ndarray   # 正規化された埋め込みベクトル

# ベクトルデータベース管理クラス
class VectorStore:
  """
  テキストのベクトル化、FAISSインデックスへの登録、
  および類似度検索を担当するクラス
  """
  def __init__(self, config: Config):
    self.config = config
    # FAISSインデックス（内積検索用）
    self.index: Optional[faiss.IndexFlatIP] = None
    # チャンクのリスト 
    self.chunks: List[RagChunk] = []   

  def _normalize(self, vec: np.ndarray) -> Optional[np.ndarray]:
    """
    ベクトルを正規化し、長さを1にする
    これにより、内積（Inner Product）による検索が
    「コサイン類似度」と同じ意味になる
    """
    norm = np.linalg.norm(vec)
    return vec / norm if norm > 0 else None

  def _embed_text(self, text: str) -> Optional[np.ndarray]:
    """
    指定したテキストをベクトルに変換し、正規化して返す
    """
    try:
      # Ollamaを使用してベクトルを生成
      result = ollama.embed(model=self.config.EMBED_MODEL, input=text)
      # 1つ目の結果をfloat32型で取得（FAISSはfloat32を要求するため）
      vec = np.array(result["embeddings"][0], dtype=np.float32)
      return self._normalize(vec)
    except Exception as e:
      print(f"【エラー】ベクトル化に失敗しました: {e}")
      return None

  def add_documents(self, data_dir: Path):
    """
    指定フォルダー内のファイルを走査し、
    内容をベクトル化してインデックスに登録する
    """
    num_files = 0
    num_ignore = 0
    added_count = 0

    # フォルダー内のファイルを1つずつ処理
    for path in data_dir.iterdir():
      try:
        # readfiles.pyを使用し、テキストをチャンクに分割して読み込む
        chunk_list = readfiles.do_read(path)
        if not chunk_list:
          continue

        for content, filename in chunk_list:
          vec = self._embed_text(content)
          if vec is not None:
            self.chunks.append(RagChunk(content, filename, vec))
            added_count += 1
        
        num_files += 1
      except Exception as e:
        print(f"【警告】ファイル {path.name} の読み込みに失敗しました: {e}")
        num_ignore += 1

    if added_count == 0:
      return

    # FAISSインデックスを構築
    self._build_faiss_index()
    
    print(f"--- 読み込み完了 ---")
    print(f"解析ファイル数: {num_files} / 失敗数: {num_ignore}")
    print(f"登録チャンク数: {added_count}")

  def _build_faiss_index(self):
    """
    保持しているチャンクのベクトルを用いて、
    FAISSの高速検索インデックスを構築する
    """
    # 全チャンクのベクトルを2次元配列に変換
    embeddings = np.array([d.embedding for d in self.chunks])
    dim = embeddings.shape[1]   # ベクトルの次元数を取得

    self.index = faiss.IndexFlatIP(dim)
    self.index.add(embeddings)

  def search(self, query: str, top_k: int = 10) -> List[Tuple[str, str]]:
    """
    質問文に類似したチャンクを検索し、しきい値以上のものだけを返す
    """
    if self.index is None or not self.chunks:
      return []

    # 質問文をベクトル化（検索時も正規化が必要）
    q_vec = self._embed_text(query)
    if q_vec is None:
      return []

    # FAISSのsearch関数は2次元配列を期待するためreshape(1, -1)を実行する
    q_vec = q_vec.reshape(1, -1)
    
    # 類似チャンクを検索
    # D：類似度スコア (高いほど似ている)
    # I：類似したチャンクのインデックス番号
    k = min(top_k, len(self.chunks))
    D, I = self.index.search(q_vec, k)

    # threasholdは、最も類似度の高いチャンクのスコアを基準に設定した比率
    # 類似度がthresholdに満たないチャンクは、top_kに入ってきても除外する
    threshold = max(D[0]) * self.config.SIMILARITY_THRESHOLD_RATIO
    
    results = []
    for rank, idx in enumerate(I[0]):
      similarity = D[0][rank]
      if similarity >= threshold:
        chunk = self.chunks[idx]
        results.append((chunk.content, chunk.filename))
    
    return results

# LLMによる回答生成
class LLMGenerator:
  """
  検索結果と質問を組み合わせて、LLMに回答を生成させるクラス
  """
  def __init__(self, config: Config):
    self.config = config

  def generate_answer(self, query: str, docs: List[Tuple[str, str]]) -> str:
    """
    検索されたチャンクをコンテキストとして注入し、LLMに回答を生成させる
    """
    if not docs:
      return "関連情報が見つかりませんでした。"

    # 検索結果を「[ファイル名]\nチャンクの本文」の形式で結合して
    # 一つのテキストにする
    context = "\n".join([f"[{filename}]\n{content}" for content, 
                        filename in docs])
    
    # プロンプトの組み立て
    prompt = self._build_prompt(query, context)
    
    try:
      # Ollamaで回答を生成
      output = ollama.generate(model=self.config.LLM_MODEL, prompt=prompt)
      return output["response"]
    except Exception as e:
      return f"【エラー】LLMによる回答生成に失敗しました: {e}"

  def _build_prompt(self, query: str, context: str) -> str:
    """
    LLMへのプロンプトを作成する
    ハルシネーション（嘘）を防ぐため、参考情報に基づいた回答を指示する
    """
    return f"""
{self.config.LLM_MODEL}が学習していること、または以下の参考情報に基づいてのみ回答してください。推測は厳禁です。

### 質問
{query}

### 参考情報
{context}

### 出力条件
- 日本語で回答すること
- 300語以内で簡潔にまとめること
- {self.config.LLM_MODEL}が学習していることには、ちゃんと答えること
- 参考情報の中に答えがない場合や{self.config.LLM_MODEL}が学習していない事柄に関しては、無理に答えず「不明」と答えること
- 回答の根拠となった情報を簡潔に添えること
"""

class RAGSystem:
  """
  VectorStoreとLLMGeneratorを組み合わせ、RAGの一連の流れを制御するクラス
  """
  def __init__(self):
    self.config = Config()
    self.store = VectorStore(self.config)
    self.generator = LLMGenerator(self.config)

  def initialize(self, data_dir: Path):
    """システムの初期化（データの読み込みとインデックス構築）を行う"""
    print("インデックスを構築しています。しばらくお待ちください...")
    self.store.add_documents(data_dir)

  def query(self, text: str):
    """
    ユーザーの質問に対して、
    「検索」→「コンテキスト注入」→「回答生成」を実行する
    """
    # ベクトルデータベースから類似チャンクを検索
    docs = self.store.search(text)
    
    # ユーザーに「どの根拠に基づいたか」を提示する
    print("\n--- 類似チャンク（文書の一部） ---")
    if not docs:
      print("該当するチャンクが見つかりませんでした")
    else:
      for content, filename in docs:
        print(f"【出典: {filename}】\n{content}\n")

    # 検索結果をLLMに渡し、最終的な回答を生成
    answer = self.generator.generate_answer(text, docs)
    print("\n--- AI回答 ---")
    print(answer)

# メイン処理
def main():
  base_dir = Path(__file__).resolve().parent
  data_dir = base_dir / Config.DATA_DIRNAME

  # RAGシステムのインスタンス化と初期化
  rag = RAGSystem()
  rag.initialize(data_dir)

  if not rag.store.chunks:
    print("エラー: 有効なデータが見つかりませんでした")
    return

  print("\n" + "="*40)
  print("RAGシステム 起動完了")
  print("質問を入力してください（5文字未満の入力で終了します）")
  print("="*40)

  while True:
    try:
      user_input = input("\n質問 > ").strip()
      
      # 終了条件：短い入力（空文字や "exit" など）でループを抜ける
      if len(user_input) < 5:
        break
      
      rag.query(user_input)
      
    except KeyboardInterrupt:
      # Ctrl＋C が押された場合に安全に終了する
      break

  print("\nプログラムを終了しました")

if __name__ == "__main__":
  main()
