"""
PII Detector & Scrubber - Format Indonesia
============================================
Deteksi dan mask data pribadi: NIK, KTP, NPWP, No HP, Email, dll.
"""

import re
from typing import Dict, List, Tuple


# Daftar kode provinsi valid untuk validasi NIK
_VALID_PROVINCE_CODES = {
    "11", "12", "13", "14", "15", "16", "17", "18", "19", "21",
    "31", "32", "33", "34", "35", "36", "51", "52", "53",
    "61", "62", "63", "64", "65", "71", "72", "73", "74", "75", "76",
    "81", "82", "91", "92", "94",
}


def _validate_nik(match_str: str) -> bool:
    """Validasi struktur NIK: kode provinsi + tanggal lahir."""
    if len(match_str) != 16:
        return False
    province = match_str[:2]
    if province not in _VALID_PROVINCE_CODES:
        return False
    day = int(match_str[6:8])
    month = int(match_str[8:10])
    # Perempuan: hari + 40
    if day > 40:
        day -= 40
    if not (1 <= day <= 31 and 1 <= month <= 12):
        return False
    return True


# Pattern definitions for Indonesian PII
PII_PATTERNS = {
    "nik": {
        "pattern": r'\b(\d{16})\b',
        "label": "NIK/KTP",
        "description": "Nomor Induk Kependudukan (16 digit)",
        "validate": _validate_nik,
    },
    "phone": {
        "pattern": r'(?<!\d)(?:\+62|62)[\s\-]?\d{2,4}[\s\-]?\d{3,4}[\s\-]?\d{3,4}(?!\d)',
        "label": "No. Telepon",
        "description": "Nomor telepon Indonesia (+62/62)",
    },
    "phone_simple": {
        "pattern": r'(?<!\d)08\d{8,11}(?!\d)',
        "label": "No. HP",
        "description": "Nomor HP Indonesia (08xx)",
    },
    "email": {
        "pattern": r'\b[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}\b',
        "label": "Email",
        "description": "Alamat email",
    },
    "npwp": {
        "pattern": r'\b\d{2}\.?\d{3}\.?\d{3}\.?\d{1}[\-\.]\d{3}\.?\d{3}\b',
        "label": "NPWP",
        "description": "Nomor Pokok Wajib Pajak",
    },
    "credit_card": {
        "pattern": r'\b\d{4}[\s\-]\d{4}[\s\-]\d{4}[\s\-]\d{4}\b',
        "label": "Kartu Kredit",
        "description": "Nomor kartu kredit/debit",
    },
    "rekening": {
        "pattern": r'(?:rekening|no\.?\s*rek(?:ening)?)[\s:]+(?:\w+\s+)?(\d{10,16})',
        "label": "No. Rekening",
        "description": "Nomor rekening bank",
    },
    "ip_address": {
        "pattern": r'\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\b',
        "label": "IP Address",
        "description": "Alamat IP",
    },
    "nama_lengkap_context": {
        "pattern": r'(?:nama\s+(?:saya|saya\s+adalah|lengkap|:))\s+([A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+){1,4})',
        "label": "Nama Lengkap",
        "description": "Nama lengkap yang disebutkan eksplisit",
    },
    "alamat_context": {
        "pattern": r'(?:alamat\s+(?:saya|rumah|:))\s+(.{10,80}?)(?:\.|$|\n)',
        "label": "Alamat",
        "description": "Alamat yang disebutkan eksplisit",
    },
}


class PIIDetector:
    """Deteksi dan scrub PII dalam teks Bahasa Indonesia."""

    def __init__(self, enabled_types: List[str] = None):
        """
        Args:
            enabled_types: List tipe PII yang di-enable.
                          None = semua aktif.
                          Options: nik, phone, email, npwp, credit_card, etc.
        """
        if enabled_types:
            self.patterns = {k: v for k, v in PII_PATTERNS.items()
                           if k in enabled_types}
        else:
            self.patterns = dict(PII_PATTERNS)

        # Compile patterns
        self.compiled = {}
        for name, info in self.patterns.items():
            self.compiled[name] = re.compile(info["pattern"], re.IGNORECASE)

    def detect(self, text: str) -> Dict:
        """
        Deteksi PII dalam teks.

        Returns:
            {
                "has_pii": bool,
                "findings": list of {type, label, value, position},
                "count": int,
            }
        """
        findings = []

        for name, pattern in self.compiled.items():
            info = self.patterns[name]
            validate_fn = info.get("validate")
            for match in pattern.finditer(text):
                # Gunakan full match untuk posisi (konsisten dengan scrub)
                full_start, full_end = match.start(), match.end()
                value = match.group(1) if match.lastindex else match.group(0)

                # Jalankan validasi jika ada
                if validate_fn and not validate_fn(value):
                    continue

                findings.append({
                    "type": name,
                    "label": info["label"],
                    "value": value,
                    "position": (full_start, full_end),
                    "description": info["description"],
                })

        return {
            "has_pii": len(findings) > 0,
            "findings": findings,
            "count": len(findings),
        }

    def scrub(self, text: str, replacement: str = "[REDACTED]") -> Dict:
        """
        Deteksi dan mask semua PII dalam teks.

        Returns:
            {
                "original": str,
                "scrubbed": str,
                "replacements": list of {type, original, replacement},
            }
        """
        result = self.detect(text)
        scrubbed = text
        replacements = []

        # Filter overlapping matches: keep yang lebih panjang
        by_length = sorted(result["findings"],
                           key=lambda x: x["position"][1] - x["position"][0],
                           reverse=True)
        filtered = []
        for finding in by_length:
            start, end = finding["position"]
            overlaps = False
            for kept in filtered:
                ks, ke = kept["position"]
                if start < ke and end > ks:
                    overlaps = True
                    break
            if not overlaps:
                filtered.append(finding)

        # Sort by position (reverse) to replace from end
        filtered.sort(key=lambda x: x["position"][0], reverse=True)

        for finding in filtered:
            start, end = finding["position"]
            label = f"[{finding['label'].upper()}]"
            original_text = scrubbed[start:end]

            scrubbed = scrubbed[:start] + label + scrubbed[end:]
            replacements.append({
                "type": finding["type"],
                "original": original_text,
                "replacement": label,
            })

        return {
            "original": text,
            "scrubbed": scrubbed,
            "replacements": replacements,
            "pii_found": len(replacements) > 0,
        }