"""
provinces.py — ตารางจังหวัดไทยครบ 77 จังหวัด พร้อมตัวย่อราชการ และตัวจับคู่แบบทนการอ่านเพี้ยน

ที่มาของข้อมูล: ไฟล์ "ตัวย่อจังหวัด-รหัสจังหวัด" ที่ผู้ใช้ส่งมา (รหัสจังหวัด + อักษรย่อไทย + อักษรย่อโรมัน)

ทำไมต้องมีตัวจับคู่แบบ fuzzy:
    OCR อ่านภาษาไทยเพี้ยนบ่อยกว่าตัวเลขมาก เพราะสระ/วรรณยุกต์เป็นอักขระแยกตัวเล็กๆ
    จากบันทึกหน้างานจริงเคยอ่านออกมาเป็น 'นครราชสีมา มห' และ 'tihariand'
    ถ้าจับแบบ "ตรงเป๊ะ" อย่างเดียว ตัวอักษรเพี้ยนตัวเดียวก็หาไม่เจอทั้งชื่อ
    จึงเทียบความคล้ายแทน และเทียบซ้ำอีกชั้นด้วย "โครงพยัญชนะ" (ตัดสระบน/ล่างออก)
    เพราะสระบน-ล่างคือส่วนที่ OCR ทำหายบ่อยที่สุด แต่พยัญชนะหลักมักอ่านได้ครบ
"""
from __future__ import annotations

import re
import unicodedata
from dataclasses import dataclass
from difflib import SequenceMatcher
from typing import Iterable, List, Optional

# (ชื่อเต็ม, อักษรย่อไทย, รหัสจังหวัด, อักษรย่อโรมัน)
PROVINCES: tuple = (
    ("กระบี่", "กบ", "81", "KBI"),
    ("กรุงเทพมหานคร", "กทม", "10", "BKK"),
    ("กาญจนบุรี", "กจ", "71", "KRI"),
    ("กาฬสินธุ์", "กส", "46", "KSN"),
    ("กำแพงเพชร", "กพ", "62", "KPT"),
    ("ขอนแก่น", "ขก", "40", "KKN"),
    ("จันทบุรี", "จบ", "22", "CTI"),
    ("ฉะเชิงเทรา", "ฉช", "24", "CCO"),
    ("ชลบุรี", "ชบ", "20", "CBI"),
    ("ชัยนาท", "ชน", "18", "CNT"),
    ("ชัยภูมิ", "ชย", "36", "CPM"),
    ("ชุมพร", "ชพ", "86", "CPN"),
    ("เชียงราย", "ชร", "57", "CRI"),
    ("เชียงใหม่", "ชม", "50", "CMI"),
    ("ตรัง", "ตง", "92", "TRG"),
    ("ตราด", "ตร", "23", "TRT"),
    ("ตาก", "ตก", "63", "TAK"),
    ("นครนายก", "นย", "26", "NYK"),
    ("นครปฐม", "นฐ", "73", "NPT"),
    ("นครพนม", "นพ", "48", "NPM"),
    ("นครราชสีมา", "นม", "30", "NMA"),
    ("นครศรีธรรมราช", "นศ", "80", "NST"),
    ("นครสวรรค์", "นว", "60", "NSN"),
    ("นนทบุรี", "นบ", "12", "NBI"),
    ("นราธิวาส", "นธ", "96", "NWT"),
    ("น่าน", "นน", "55", "NAN"),
    ("บึงกาฬ", "บก", "38", "BKN"),
    ("บุรีรัมย์", "บร", "31", "BRM"),
    ("ปทุมธานี", "ปท", "13", "PTE"),
    ("ประจวบคีรีขันธ์", "ปข", "77", "PKN"),
    ("ปราจีนบุรี", "ปจ", "25", "PRI"),
    ("ปัตตานี", "ปน", "94", "PTN"),
    ("พะเยา", "พย", "56", "PYO"),
    ("พระนครศรีอยุธยา", "อย", "14", "AYA"),
    ("พังงา", "พง", "82", "PNA"),
    ("พัทลุง", "พท", "93", "PLG"),
    ("พิจิตร", "พจ", "66", "PCT"),
    ("พิษณุโลก", "พล", "65", "PLK"),
    ("เพชรบุรี", "พบ", "76", "PBI"),
    ("เพชรบูรณ์", "พช", "67", "PNB"),
    ("แพร่", "พร", "54", "PRE"),
    ("ภูเก็ต", "ภก", "83", "PKT"),
    ("มหาสารคาม", "มค", "44", "MKM"),
    ("มุกดาหาร", "มห", "49", "MDH"),
    ("แม่ฮ่องสอน", "มส", "58", "MSN"),
    ("ยโสธร", "ยส", "35", "YST"),
    ("ยะลา", "ยล", "95", "YLA"),
    ("ร้อยเอ็ด", "รอ", "45", "RET"),
    ("ระนอง", "รน", "85", "RNG"),
    ("ระยอง", "รย", "21", "RYG"),
    ("ราชบุรี", "รบ", "70", "RBR"),
    ("ลพบุรี", "ลบ", "16", "LRI"),
    ("ลำปาง", "ลป", "52", "LPG"),
    ("ลำพูน", "ลพ", "51", "LPN"),
    ("เลย", "ลย", "42", "LEI"),
    ("ศรีสะเกษ", "ศก", "33", "SSK"),
    ("สกลนคร", "สน", "47", "SNK"),
    ("สงขลา", "สข", "90", "SKA"),
    ("สตูล", "สต", "91", "STN"),
    ("สมุทรปราการ", "สป", "11", "SPK"),
    ("สมุทรสงคราม", "สส", "75", "SKM"),
    ("สมุทรสาคร", "สค", "74", "SKN"),
    ("สระแก้ว", "สก", "27", "SKW"),
    ("สระบุรี", "สบ", "19", "SRI"),
    ("สิงห์บุรี", "สห", "17", "SBR"),
    ("สุโขทัย", "สท", "64", "STI"),
    ("สุพรรณบุรี", "สพ", "72", "SPB"),
    ("สุราษฎร์ธานี", "สฎ", "84", "SNI"),
    ("สุรินทร์", "สร", "32", "SRN"),
    ("หนองคาย", "นค", "43", "NKI"),
    ("หนองบัวลำภู", "นภ", "39", "NBP"),
    ("อ่างทอง", "อท", "15", "ATG"),
    ("อำนาจเจริญ", "อจ", "37", "ACR"),
    ("อุดรธานี", "อด", "41", "UDN"),
    ("อุตรดิตถ์", "อต", "53", "UTT"),
    ("อุทัยธานี", "อน", "61", "UTI"),
    ("อุบลราชธานี", "อบ", "34", "UBN"),
)

# ชื่อเรียกสั้นที่คนใช้จริงและ OCR มักอ่านได้แค่ท่อนนี้ -> ชื่อเต็มที่ถูกต้อง
ALIASES: dict = {
    "กรุงเทพ": "กรุงเทพมหานคร",
    "กทม": "กรุงเทพมหานคร",
    "อยุธยา": "พระนครศรีอยุธยา",
    "ศรีอยุธยา": "พระนครศรีอยุธยา",
    "โคราช": "นครราชสีมา",
}

# สระบน/สระล่าง/วรรณยุกต์/การันต์ — ส่วนที่ OCR ทำหายหรือเพี้ยนบ่อยที่สุด
_THAI_MARKS = re.compile(r"[ัิ-ฺ็-๎]")
# เก็บเฉพาะอักษรไทย ตัดช่องว่างและอักขระอื่นทิ้ง (OCR ชอบแทรกช่องว่างกลางคำ)
_NON_THAI = re.compile(r"[^฀-๿]")

# เกณฑ์ความคล้ายขั้นต่ำ ตั้งค่อนข้างสูงเพราะชื่อจังหวัดไทยหลายคู่คล้ายกันมาก
# (นครปฐม / นครพนม / นครนายก — ต่างกันแค่ท้ายคำ) ตั้งต่ำไปจะจับผิดจังหวัด
_MIN_RATIO_FULL = 0.78      # เทียบชื่อเต็มตามตัวอักษรจริง
_MIN_RATIO_SKELETON = 0.88  # เทียบเฉพาะโครงพยัญชนะ ต้องเข้มกว่าเพราะข้อมูลน้อยลง
_MIN_LEN = 3                # ข้อความสั้นกว่านี้ไม่ต้องเดา มั่วมากกว่าถูก


@dataclass
class ProvinceMatch:
    """ผลการจับคู่จังหวัด — เก็บคะแนนไว้ด้วยเพื่อให้ชั้นบนตัดสินใจต่อได้"""
    name: str            # ชื่อเต็ม เช่น 'กรุงเทพมหานคร'
    abbr: str            # อักษรย่อไทย เช่น 'กทม'
    code: str            # รหัสจังหวัด เช่น '10'
    roman: str           # อักษรย่อโรมัน เช่น 'BKK'
    score: float         # 1.0 = ตรงเป๊ะ, ต่ำกว่านั้น = จับแบบคล้าย
    exact: bool          # True = เจอชื่อตรงตัวในข้อความ ไม่ได้เดา


def _norm(text: str) -> str:
    """เหลือเฉพาะอักษรไทยติดกัน — ตัดช่องว่างที่ OCR แทรกกลางคำออก"""
    if not text:
        return ""
    return _NON_THAI.sub("", unicodedata.normalize("NFC", text))


def _skeleton(text: str) -> str:
    """โครงพยัญชนะ: ตัดสระบน/ล่างและวรรณยุกต์ออก เหลือตัวที่ OCR มักอ่านติด"""
    return _THAI_MARKS.sub("", text)


def _best_window_ratio(haystack: str, needle: str) -> float:
    """
    หาความคล้ายสูงสุดของ needle กับ "ท่อนใดท่อนหนึ่ง" ใน haystack

    ต้องเลื่อนหน้าต่างเทียบ เพราะ OCR มักอ่านชื่อจังหวัดติดมากับขยะข้างเคียง
    เช่น 'นครราชสีมา มห' ถ้าเทียบทั้งก้อนคะแนนจะตกเพราะส่วนเกิน
    """
    if not haystack or not needle:
        return 0.0
    n = len(needle)
    if len(haystack) <= n:
        return SequenceMatcher(None, haystack, needle).ratio()
    best = 0.0
    # เผื่อความยาวคลาดเคลื่อน ±2 ตัว (OCR ตกหล่น/เกินได้)
    for width in (n - 2, n - 1, n, n + 1, n + 2):
        if width < _MIN_LEN or width > len(haystack):
            continue
        for i in range(len(haystack) - width + 1):
            r = SequenceMatcher(None, haystack[i:i + width], needle).ratio()
            if r > best:
                best = r
                if best >= 0.999:
                    return best
    return best


def match_province(texts: Iterable[str]) -> Optional[ProvinceMatch]:
    """
    หาจังหวัดจากข้อความทั้งหมดที่ OCR อ่านได้

    ทำ 3 ชั้นจากแม่นไปหยาบ หยุดทันทีที่เจอชั้นที่แม่นกว่า:
      1) เจอชื่อเต็ม/ชื่อย่อที่คนใช้จริง ตรงตัวในข้อความ  -> score 1.0
      2) เทียบความคล้ายกับชื่อเต็ม                        -> ต้อง >= 0.78
      3) เทียบความคล้ายเฉพาะโครงพยัญชนะ (สระหาย)          -> ต้อง >= 0.88
    """
    chunks: List[str] = [_norm(t) for t in texts if t]
    chunks = [c for c in chunks if len(c) >= _MIN_LEN]
    if not chunks:
        return None
    joined = "".join(chunks)

    by_name = {p[0]: p for p in PROVINCES}

    # ---- ชั้น 1: ตรงตัว ----
    # ไล่จากชื่อยาวไปสั้น กัน 'นครปฐม' ถูก 'นครศรีธรรมราช' แย่งจับ และกัน
    # alias สั้นๆ อย่าง 'กรุงเทพ' ชนะชื่อเต็ม 'กรุงเทพมหานคร'
    candidates = [(p[0], p[0]) for p in PROVINCES] + list(ALIASES.items())
    for probe, full in sorted(candidates, key=lambda x: -len(x[0])):
        if _norm(probe) in joined:
            p = by_name[full]
            return ProvinceMatch(p[0], p[1], p[2], p[3], 1.0, True)

    # ---- ชั้น 2 และ 3: เทียบความคล้าย ----
    for use_skeleton, threshold in ((False, _MIN_RATIO_FULL), (True, _MIN_RATIO_SKELETON)):
        best_score, best_p = 0.0, None
        for p in PROVINCES:
            target = _skeleton(p[0]) if use_skeleton else p[0]
            if len(target) < _MIN_LEN:
                continue
            for c in chunks:
                hay = _skeleton(c) if use_skeleton else c
                r = _best_window_ratio(hay, target)
                if r > best_score:
                    best_score, best_p = r, p
        if best_p and best_score >= threshold:
            return ProvinceMatch(best_p[0], best_p[1], best_p[2], best_p[3],
                                 round(best_score, 3), False)

    return None


def abbr_of(province_name: Optional[str]) -> Optional[str]:
    """แปลงชื่อเต็มจังหวัดเป็นอักษรย่อ (ใช้ตอนข้อมูลมาจากที่อื่น เช่น ฐานข้อมูล)"""
    if not province_name:
        return None
    key = _norm(province_name)
    for name, abbr, _code, _roman in PROVINCES:
        if _norm(name) == key:
            return abbr
    return ALIASES.get(province_name) and abbr_of(ALIASES[province_name])


def format_plate(plate: Optional[str], abbr: Optional[str]) -> Optional[str]:
    """
    รูปแบบที่ใช้แสดงหน้างาน: อักษรย่อจังหวัดนำหน้าเลขทะเบียนติดกัน เช่น 'กทม98-9559'
    ถ้าอ่านจังหวัดไม่ได้ ให้คืนเลขทะเบียนเปล่าๆ ไม่ต้องเดาจังหวัดมาเติม
    """
    if not plate:
        return plate
    return f"{abbr}{plate}" if abbr else plate
