package jp

import (
	"bytes"
	"compress/gzip"
	_ "embed"
	"encoding/json"
	"os"
	"reflect"
	"testing"
)

func TestScriptPredicates(t *testing.T) {
	// Hiragana
	for _, r := range []rune{'あ', 'ん', 'ぁ', 'ゝ', 'ゞ'} {
		if !IsHiragana(r) {
			t.Errorf("IsHiragana(%c) = false, want true", r)
		}
	}
	for _, r := range []rune{'ア', '漢', 'a', '1', 'ー'} {
		if IsHiragana(r) {
			t.Errorf("IsHiragana(%c) = true, want false", r)
		}
	}

	// Katakana
	for _, r := range []rune{'ア', 'ン', 'ァ', 'ー', 'ｰ', 'ｱ', 'ﾝ', 'ヽ', 'ヾ'} {
		if !IsKatakana(r) {
			t.Errorf("IsKatakana(%c) = false, want true", r)
		}
	}
	for _, r := range []rune{'あ', '漢', 'a', '1'} {
		if IsKatakana(r) {
			t.Errorf("IsKatakana(%c) = true, want false", r)
		}
	}

	// Kana
	for _, r := range []rune{'あ', 'ア', 'ー', 'ｱ'} {
		if !IsKana(r) {
			t.Errorf("IsKana(%c) = false, want true", r)
		}
	}
	for _, r := range []rune{'漢', 'a', '1'} {
		if IsKana(r) {
			t.Errorf("IsKana(%c) = true, want false", r)
		}
	}

	// Kanji: CJK unified ideographs + ext A + 々〆ヵヶ
	for _, r := range []rune{'漢', '字', '々', '〆', 'ヵ', 'ヶ', rune(0x3400), rune(0x4DBF)} {
		if !IsKanji(r) {
			t.Errorf("IsKanji(%c / %U) = false, want true", r, r)
		}
	}
	for _, r := range []rune{'あ', 'ア', 'a', '1', ' '} {
		if IsKanji(r) {
			t.Errorf("IsKanji(%c) = true, want false", r)
		}
	}

	// HasJapanese
	if !HasJapanese("hello 世界") {
		t.Errorf("HasJapanese('hello 世界') = false, want true")
	}
	if !HasJapanese("こんにちは") {
		t.Errorf("HasJapanese('こんにちは') = false, want true")
	}
	if !HasJapanese("ラーメン") {
		t.Errorf("HasJapanese('ラーメン') = false, want true")
	}
	if HasJapanese("hello world 123 !?") {
		t.Errorf("HasJapanese('hello world 123 !?') = true, want false")
	}

	// IsKanaOnly
	if !IsKanaOnly("こんにちは") {
		t.Errorf("IsKanaOnly('こんにちは') = false, want true")
	}
	if !IsKanaOnly("ラーメン") {
		t.Errorf("IsKanaOnly('ラーメン') = false, want true")
	}
	if IsKanaOnly("こんにちは、世界！") {
		t.Errorf("IsKanaOnly('こんにちは、世界！') = true, want false")
	}
	if !IsKanaOnly("こんにちは！") {
		t.Errorf("IsKanaOnly('こんにちは！') = false, want true")
	}
	if IsKanaOnly("ーーー") {
		t.Errorf("IsKanaOnly('ーーー') = true, want false (no kana letters)")
	}
	if IsKanaOnly("hello") {
		t.Errorf("IsKanaOnly('hello') = true, want false")
	}
}

func TestKanaConversion(t *testing.T) {
	if got := ToHiragana("ラーメン"); got != "らーめん" {
		t.Errorf("ToHiragana(ラーメン) = %q, want %q", got, "らーめん")
	}
	if got := ToKatakana("らーめん"); got != "ラーメン" {
		t.Errorf("ToKatakana(らーめん) = %q, want %q", got, "ラーメン")
	}
	if got := ToHiragana("ｱｲｳｴｵ"); got != "あいうえお" {
		t.Errorf("ToHiragana(ｱｲｳｴｵ) = %q, want %q", got, "あいうえお")
	}
}

func TestMoras(t *testing.T) {
	tests := []struct {
		input string
		want  []string
	}{
		{"きょうと", []string{"きょ", "う", "と"}},
		{"がっこう", []string{"が", "っ", "こ", "う"}},
		{"コーヒー", []string{"コ", "ー", "ヒ", "ー"}},
		{"ほんや", []string{"ほ", "ん", "や"}},
		{"ティーパーティー", []string{"ティ", "ー", "パ", "ー", "ティ", "ー"}},
	}
	for _, tc := range tests {
		got := Moras(tc.input)
		if !reflect.DeepEqual(got, tc.want) {
			t.Errorf("Moras(%q) = %v, want %v", tc.input, got, tc.want)
		}
	}
}

func TestRomaji(t *testing.T) {
	tests := []struct {
		input string
		style Style
		want  string
	}{
		// きょう -> kyou in context-free Romaji
		{"きょう", Macron, "kyou"},
		{"きょう", Wapuro, "kyou"},
		{"きょう", Plain, "kyou"},

		// がっこう
		{"がっこう", Macron, "gakkou"},
		{"がっこう", Wapuro, "gakkou"},

		// まっちゃ -> matcha
		{"まっちゃ", Macron, "matcha"},
		{"まっちゃ", Wapuro, "matcha"},

		// ほんや -> hon'ya
		{"ほんや", Macron, "hon'ya"},
		{"ほんや", Wapuro, "hon'ya"},

		// きんえん -> kin'en
		{"きんえん", Macron, "kin'en"},
		{"きんえん", Wapuro, "kin'en"},

		// しんぶん -> shinbun (not shimbun)
		{"しんぶん", Macron, "shinbun"},
		{"しんぶん", Wapuro, "shinbun"},

		// コーヒー
		{"コーヒー", Macron, "kōhī"},
		{"コーヒー", Wapuro, "koohii"},
		{"コーヒー", Plain, "kohi"},

		// Particle を / ヲ
		{"を", Macron, "o"},
		{"を", Plain, "o"},
		{"を", Wapuro, "wo"},
		{"ヲ", Macron, "o"},
		{"ヲ", Plain, "o"},
		{"ヲ", Wapuro, "wo"},
	}

	for _, tc := range tests {
		got := Romaji(tc.input, tc.style)
		if got != tc.want {
			t.Errorf("Romaji(%q, style=%v) = %q, want %q", tc.input, tc.style, got, tc.want)
		}
	}
}

func TestRomajiPron(t *testing.T) {
	tests := []struct {
		reading string
		pron    string
		style   Style
		want    string
	}{
		// きょう -> kyō only via RomajiPron(キョウ, キョー)
		{"キョウ", "キョー", Macron, "kyō"},
		{"キョウ", "キョー", Wapuro, "kyou"},
		{"キョウ", "キョー", Plain, "kyo"},

		// トウキョウ
		{"トウキョウ", "トーキョー", Macron, "tōkyō"},
		{"トウキョウ", "トーキョー", Wapuro, "toukyou"},
		{"トウキョウ", "トーキョー", Plain, "tokyo"},

		// オモウ
		{"オモウ", "オモウ", Macron, "omou"},
		{"オモウ", "オモウ", Wapuro, "omou"},
		{"オモウ", "オモウ", Plain, "omou"},

		// センセイ
		{"センセイ", "センセー", Macron, "sensei"},
		{"センセイ", "センセー", Wapuro, "sensei"},
		{"センセイ", "センセー", Plain, "sensei"},

		// ハ -> wa
		{"ハ", "ワ", Macron, "wa"},
		{"ハ", "ワ", Wapuro, "wa"},

		// オオキイ
		{"オオキイ", "オーキイ", Macron, "ōkii"},
		{"オオキイ", "オーキイ", Wapuro, "ookii"},
		{"オオキイ", "オーキイ", Plain, "okii"},

		// ヘ -> e
		{"ヘ", "エ", Macron, "e"},
		{"ヘ", "エ", Wapuro, "e"},

		// ヲ -> o (in Macron and Plain, and when pron is オ)
		{"ヲ", "オ", Macron, "o"},
		{"ヲ", "オ", Plain, "o"},
		{"ヲ", "オ", Wapuro, "o"},

		// ヲ with pron ヲ: "o" in Macron & Plain per Hepburn, "wo" in Wapuro per WanaKana
		{"ヲ", "ヲ", Macron, "o"},
		{"ヲ", "ヲ", Plain, "o"},
		{"ヲ", "ヲ", Wapuro, "wo"},
	}

	for _, tc := range tests {
		got := RomajiPron(tc.reading, tc.pron, tc.style)
		if got != tc.want {
			t.Errorf("RomajiPron(%q, %q, style=%v) = %q, want %q", tc.reading, tc.pron, tc.style, got, tc.want)
		}
	}
}

func TestIterationMarks(t *testing.T) {
	if got := Romaji("さゝ", Macron); got != "sasa" {
		t.Errorf("Romaji('さゝ') = %q, want 'sasa'", got)
	}
	if got := Romaji("はゞ", Macron); got != "haba" {
		t.Errorf("Romaji('はゞ') = %q, want 'haba'", got)
	}
	if got := Romaji("サヽ", Macron); got != "sasa" {
		t.Errorf("Romaji('サヽ') = %q, want 'sasa'", got)
	}
	if got := Romaji("ハヾ", Macron); got != "haba" {
		t.Errorf("Romaji('ハヾ') = %q, want 'haba'", got)
	}
}

func TestRomajiFallbacks(t *testing.T) {
	if got := RomajiPron("きょう", "", Macron); got != "kyou" {
		t.Errorf("RomajiPron('きょう', '') = %q, want 'kyou'", got)
	}
	if got := RomajiPron("きょう", "トウキョウ", Macron); got != "kyou" {
		t.Errorf("RomajiPron mismatched = %q, want 'kyou'", got)
	}
}

func TestRomajiPunctuation(t *testing.T) {
	if got := Romaji("こんにちは!", Macron); got != "konnichiha!" {
		t.Errorf("Romaji('こんにちは!') = %q, want 'konnichiha!'", got)
	}
}

//go:embed testdata/wanakana_sample_5k.json.gz
var wanakanaSampleGz []byte

// TestWanaKanaParity verifies 100% parity against real WanaKana over distinct JMdict kana readings.
// By default it tests the embedded 5k representative sample hermetically.
// If testdata/wanakana_pairs.json.gz is present, it tests the complete 193,414 readings.
func TestWanaKanaParity(t *testing.T) {
	var gzReader *gzip.Reader
	var err error

	fullPath := "testdata/wanakana_pairs.json.gz"
	if f, errOpen := os.Open(fullPath); errOpen == nil {
		defer f.Close()
		gzReader, err = gzip.NewReader(f)
	} else {
		gzReader, err = gzip.NewReader(bytes.NewReader(wanakanaSampleGz))
	}
	if err != nil {
		t.Fatalf("failed to create gzip reader: %v", err)
	}
	defer gzReader.Close()

	var pairs [][]string
	if err := json.NewDecoder(gzReader).Decode(&pairs); err != nil {
		t.Fatalf("failed to decode json: %v", err)
	}

	mismatches := 0
	for _, p := range pairs {
		kana := p[0]
		expected := p[1]
		got := Romaji(kana, Wapuro)
		if got != expected {
			mismatches++
			if mismatches <= 10 {
				t.Errorf("WanaKana mismatch for %q: got %q, want %q", kana, got, expected)
			}
		}
	}
	t.Logf("Tested %d distinct kana readings against WanaKana: %d mismatches", len(pairs), mismatches)
	if mismatches != 0 {
		t.Fatalf("expected 0 mismatches, got %d", mismatches)
	}
}