# よくある文字化け問題
text = "こんにちは"
print(text.encode('utf-8').decode('shift_jis'))  # 文字化け発生
# UnicodeDecodeError: 'shift_jis' codec can't decode byte...

# 英語：自然にスペースで分割
english = "Natural language processing is difficult"
words = english.split()  # ['Natural', 'language', 'processing', 'is', 'difficult']

# 日本語：分割位置が不明確
japanese = "自然言語処理は難しい"
# どこで区切る？「自然」「言語」「処理」？「自然言語」「処理」？

# 同じ意味でも表現が多様
sentences = [
    "行く",           # 基本形
    "行きます",       # 丁寧語
    "いらっしゃる",   # 尊敬語
    "参る",           # 謙譲語
]
# これらを同じ意味として処理する必要がある

# 同じ読みでも異なる意味
words = ["橋", "端", "箸"]  # すべて「はし」と読む
# 文脈なしでは意味を特定できない

# 正解の分割が複数存在
text = "今日は学校に行く"

# 分割候補1
segmentation1 = ["今日", "は", "学校", "に", "行く"]

# 分割候補2  
segmentation2 = ["今日", "は", "学", "校", "に", "行く"]

# どちらが正解？用途によって異なる

import chardet
import codecs

class JapaneseTextProcessor:
    def __init__(self):
        self.common_encodings = ['utf-8', 'shift_jis', 'euc-jp', 'iso-2022-jp']
    
    def detect_encoding(self, file_path):
        """ファイルのエンコーディングを自動検出"""
        with open(file_path, 'rb') as f:
            raw_data = f.read()
            result = chardet.detect(raw_data)
            return result['encoding']
    
    def safe_read_text(self, file_path):
        """エンコーディングを自動判定して安全に読み込み"""
        encoding = self.detect_encoding(file_path)
        
        try:
            with open(file_path, 'r', encoding=encoding) as f:
                return f.read()
        except UnicodeDecodeError:
            # フォールバック処理
            for enc in self.common_encodings:
                try:
                    with open(file_path, 'r', encoding=enc) as f:
                        return f.read()
                except UnicodeDecodeError:
                    continue
            
            # 最終手段：エラー文字を置換
            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
                return f.read()
    
    def normalize_text(self, text):
        """テキストの正規化"""
        import unicodedata
        
        # Unicode正規化（NFKCを推奨）
        normalized = unicodedata.normalize('NFKC', text)
        
        # 全角・半角の統一
        normalized = self.normalize_width(normalized)
        
        return normalized
    
    def normalize_width(self, text):
        """全角・半角の統一"""
        # 全角英数字を半角に変換
        text = text.translate(str.maketrans(
            '０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ',
            '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
        ))
        
        # 半角カタカナを全角に変換
        text = self.hankaku_to_zenkaku_katakana(text)
        
        return text
    
    def hankaku_to_zenkaku_katakana(self, text):
        """半角カタカナを全角に変換"""
        hankaku = 'ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜｦﾝ'
        zenkaku = 'アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲン'
        
        for h, z in zip(hankaku, zenkaku):
            text = text.replace(h, z)
        
        return text

# 使用例
processor = JapaneseTextProcessor()

# 安全なファイル読み込み
text = processor.safe_read_text("japanese_document.txt")

# テキスト正規化
normalized_text = processor.normalize_text(text)

import MeCab
import re

class AdvancedJapaneseMorphAnalyzer:
    def __init__(self):
        # NEologd辞書を使用（新語・固有名詞に強い）
        try:
            self.tagger = MeCab.Tagger('-d /usr/local/lib/mecab/dic/mecab-ipadic-neologd')
        except:
            # フォールバック：デフォルト辞書
            self.tagger = MeCab.Tagger()
    
    def tokenize_with_pos(self, text):
        """品詞情報付きトークン化"""
        tokens = []
        
        # 前処理：句読点で分割して処理
        sentences = re.split(r'[。！？]', text)
        
        for sentence in sentences:
            if not sentence.strip():
                continue
                
            node = self.tagger.parseToNode(sentence)
            while node:
                if node.feature != 'BOS/EOS':
                    features = node.feature.split(',')
                    
                    token_info = {
                        'surface': node.surface,
                        'pos': features[0],           # 品詞
                        'pos_detail': features[1],    # 品詞細分類
                        'base_form': features[6] if len(features) > 6 else node.surface,
                        'reading': features[7] if len(features) > 7 else None
                    }
                    tokens.append(token_info)
                
                node = node.next
        
        return tokens
    
    def extract_content_words(self, text):
        """内容語（名詞・動詞・形容詞）の抽出"""
        tokens = self.tokenize_with_pos(text)
        
        content_words = []
        for token in tokens:
            pos = token['pos']
            if pos in ['名詞', '動詞', '形容詞']:
                # 基本形を使用
                word = token['base_form']
                if word and len(word) > 1:  # 一文字は除外
                    content_words.append(word)
        
        return content_words
    
    def normalize_verbs_and_adjectives(self, text):
        """動詞・形容詞の原形統一"""
        tokens = self.tokenize_with_pos(text)
        
        normalized_text = ""
        for token in tokens:
            if token['pos'] in ['動詞', '形容詞']:
                normalized_text += token['base_form']
            else:
                normalized_text += token['surface']
        
        return normalized_text

# 使用例
analyzer = AdvancedJapaneseMorphAnalyzer()

text = "今日は天気が良かったので、公園に行きました。"
tokens = analyzer.tokenize_with_pos(text)

for token in tokens:
    print(f"{token['surface']}\t{token['pos']}\t{token['base_form']}")

# 内容語の抽出
content_words = analyzer.extract_content_words(text)
print("内容語:", content_words)

class JapanesePolitenesNormalizer:
    def __init__(self):
        # 敬語の対応表
        self.honorific_mapping = {
            # 尊敬語 → 基本形
            'いらっしゃる': '行く',
            'おっしゃる': '言う',
            'なさる': 'する',
            'ご覧になる': '見る',
            
            # 謙譲語 → 基本形
            '参る': '行く',
            '申す': '言う',
            '致す': 'する',
            '拝見する': '見る',
            
            # 丁寧語 → 基本形
            '行きます': '行く',
            '言います': '言う',
            'します': 'する',
            '見ます': '見る',
        }
        
        # 敬語パターンの正規表現
        self.polite_patterns = [
            (r'(.+)でございます', r'\1だ'),
            (r'(.+)いらっしゃいます', r'\1いる'),
            (r'(.+)ていただく', r'\1てもらう'),
            (r'(.+)させていただく', r'\1する'),
        ]
    
    def normalize_politeness(self, text):
        """敬語レベルを基本形に統一"""
        normalized = text
        
        # 直接対応表での置換
        for polite, plain in self.honorific_mapping.items():
            normalized = normalized.replace(polite, plain)
        
        # パターンマッチングでの置換
        for pattern, replacement in self.polite_patterns:
            normalized = re.sub(pattern, replacement, normalized)
        
        return normalized
    
    def detect_politeness_level(self, text):
        """敬語レベルの検出"""
        levels = {
            'casual': 0,      # 普通体
            'polite': 0,      # 丁寧語
            'respectful': 0,  # 尊敬語
            'humble': 0       # 謙譲語
        }
        
        # 丁寧語の検出
        if any(word in text for word in ['です', 'ます', 'ございます']):
            levels['polite'] += 1
        
        # 尊敬語の検出
        respectful_words = ['いらっしゃる', 'おっしゃる', 'なさる']
        if any(word in text for word in respectful_words):
            levels['respectful'] += 1
        
        # 謙譲語の検出
        humble_words = ['参る', '申す', '致す', 'いただく']
        if any(word in text for word in humble_words):
            levels['humble'] += 1
        
        # 最も多いレベルを返す
        return max(levels.items(), key=lambda x: x[1])[0]

# 使用例
normalizer = JapanesePolitenesNormalizer()

texts = [
    "明日会社に参ります",
    "明日会社に行きます", 
    "明日会社に行く"
]

for text in texts:
    normalized = normalizer.normalize_politeness(text)
    level = normalizer.detect_politeness_level(text)
    print(f"原文: {text}")
    print(f"正規化: {normalized}")
    print(f"敬語レベル: {level}\n")

from gensim.models import Word2Vec
import numpy as np

class JapaneseHomonymResolver:
    def __init__(self, model_path=None):
        if model_path:
            self.word2vec_model = Word2Vec.load(model_path)
        else:
            # 事前学習済みモデルをロード
            self.word2vec_model = self.load_pretrained_model()
    
    def load_pretrained_model(self):
        """日本語事前学習済みWord2Vecモデルのロード"""
        # 実際の実装では、適切な事前学習済みモデルを使用
        # 例：chiVe（日本語Word2Vec）
        try:
            from gensim.models import KeyedVectors
            return KeyedVectors.load_word2vec_format('chive-1.2-mc5.kv')
        except:
            # デモ用の簡易モデル作成
            sentences = [
                ['橋', '川', '渡る'],
                ['端', '隅', '位置'],
                ['箸', '食事', '道具']
            ]
            return Word2Vec(sentences, vector_size=100, min_count=1)
    
    def resolve_homonym(self, target_word, context_words, candidates):
        """文脈を使った同音異義語の解決"""
        if target_word not in candidates:
            return target_word
        
        best_candidate = target_word
        best_similarity = -1
        
        for candidate in candidates:
            if candidate not in self.word2vec_model.wv:
                continue
            
            # 文脈語との類似度の平均を計算
            similarities = []
            for context_word in context_words:
                if context_word in self.word2vec_model.wv:
                    sim = self.word2vec_model.wv.similarity(candidate, context_word)
                    similarities.append(sim)
            
            if similarities:
                avg_similarity = np.mean(similarities)
                if avg_similarity > best_similarity:
                    best_similarity = avg_similarity
                    best_candidate = candidate
        
        return best_candidate
    
    def process_sentence(self, sentence, homonym_dict):
        """文章全体での同音異義語解決"""
        # 形態素解析
        analyzer = AdvancedJapaneseMorphAnalyzer()
        tokens = analyzer.tokenize_with_pos(sentence)
        
        resolved_tokens = []
        
        for i, token in enumerate(tokens):
            surface = token['surface']
            
            if surface in homonym_dict:
                # 前後の文脈を取得
                context_words = []
                for j in range(max(0, i-3), min(len(tokens), i+4)):
                    if j != i and tokens[j]['pos'] in ['名詞', '動詞', '形容詞']:
                        context_words.append(tokens[j]['surface'])
                
                # 同音異義語解決
                candidates = homonym_dict[surface]
                resolved = self.resolve_homonym(surface, context_words, candidates)
                resolved_tokens.append(resolved)
            else:
                resolved_tokens.append(surface)
        
        return ''.join(resolved_tokens)

# 使用例
resolver = JapaneseHomonymResolver()

# 同音異義語の辞書
homonym_dict = {
    'はし': ['橋', '端', '箸'],
    'かみ': ['紙', '髪', '神'],
    'あめ': ['雨', '飴']
}

sentences = [
    "川に架かるはしを渡る",
    "机のはしに置く",
    "はしで食べる"
]

for sentence in sentences:
    resolved = resolver.process_sentence(sentence, homonym_dict)
    print(f"原文: {sentence}")
    print(f"解決: {resolved}\n")

class ComprehensiveJapaneseNLPPipeline:
    def __init__(self):
        self.text_processor = JapaneseTextProcessor()
        self.morph_analyzer = AdvancedJapaneseMorphAnalyzer()
        self.politeness_normalizer = JapanesePolitenesNormalizer()
        self.homonym_resolver = JapaneseHomonymResolver()
    
    def process_text(self, text, 
                    normalize_text=True,
                    normalize_politeness=True,
                    resolve_homonyms=True,
                    extract_content_words=True):
        """包括的なテキスト処理"""
        
        results = {
            'original': text,
            'processed': text
        }
        
        # 1. テキスト正規化
        if normalize_text:
            text = self.text_processor.normalize_text(text)
            results['normalized'] = text
        
        # 2. 敬語正規化
        if normalize_politeness:
            text = self.politeness_normalizer.normalize_politeness(text)
            results['politeness_normalized'] = text
        
        # 3. 同音異義語解決
        if resolve_homonyms:
            homonym_dict = {'はし': ['橋', '端', '箸']}  # 実際にはより大きな辞書を使用
            text = self.homonym_resolver.process_sentence(text, homonym_dict)
            results['homonym_resolved'] = text
        
        # 4. 内容語抽出
        if extract_content_words:
            content_words = self.morph_analyzer.extract_content_words(text)
            results['content_words'] = content_words
        
        results['processed'] = text
        return results
    
    def batch_process(self, texts, **kwargs):
        """バッチ処理"""
        results = []
        for text in texts:
            result = self.process_text(text, **kwargs)
            results.append(result)
        return results

# 使用例
pipeline = ComprehensiveJapaneseNLPPipeline()

test_texts = [
    "今日は会社にいらっしゃいますか？",
    "橋の上で雨に濡れました。",
    "明日の会議に参加させていただきます。"
]

results = pipeline.batch_process(test_texts)

for result in results:
    print(f"原文: {result['original']}")
    print(f"処理結果: {result['processed']}")
    print(f"内容語: {result['content_words']}")
    print("---")

# 導入前の問題例
search_query = "会議に参加する"
documents = [
    "明日の会議に参ります",      # 謙譲語
    "会議にいらっしゃいますか",  # 尊敬語  
    "会議に行きます"            # 丁寧語
]

# 従来のキーワード検索：0件ヒット（表現が異なるため）

# 導入後の結果
pipeline = ComprehensiveJapaneseNLPPipeline()

# 検索クエリの正規化
normalized_query = pipeline.process_text(search_query)['processed']

# 文書の正規化
normalized_docs = []
for doc in documents:
    normalized_doc = pipeline.process_text(doc)['processed']
    normalized_docs.append(normalized_doc)

# 結果：すべての文書が「会議に行く」として統一され、検索可能