# sms_service.py

import requests
import os
import json
import re
import fcntl
import logging
from datetime import datetime
from typing import List, Optional
import jdatetime

logger = logging.getLogger('sms_service')

# ============================================================
# تنظیمات استاندارد مهندسی پایداری (Hysteresis)
# ============================================================
FAILURE_THRESHOLD = 5
SUCCESS_THRESHOLD = 2
MAX_SMS_LENGTH = 70
PROVIDER_SUFFIX_LEN = 6
EFFECTIVE_MAX = MAX_SMS_LENGTH - PROVIDER_SUFFIX_LEN  # 64

TRACKER_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'sms_tracker.json')

_SMS_ERROR_MARKERS = (
    'نامعتبر', 'خطا', 'اشتباه', 'مجوز', 'اعتبار', 'یافت نشد', 'خالی',
    'invalid', 'error', 'fail', 'unauthorized', 'denied', 'forbidden', 'not found',
)

def is_send_success(data) -> bool:
    """تشخیص موفقیت ارسال وب‌وان.
    نکته: مستندات کلید را "Succeeded" نوشته، ولی پنل در عمل "succeeded" برمی‌گرداند؛
    هر دو پشتیبانی می‌شوند و در نبود کلید، resultCode==0 ملاک است."""
    if not isinstance(data, dict):
        return False
    succeeded = data.get("succeeded", data.get("Succeeded"))
    if isinstance(succeeded, bool):
        return succeeded
    return data.get("resultCode") == 0

def _sms_body_has_error(body: str) -> bool:
    """وب‌وان حتی در خطا HTTP 200 می‌دهد؛ تنها راه تشخیص، خواندن بدنه است."""
    low = (body or '').strip().lower()
    return any(m in low for m in _SMS_ERROR_MARKERS)

def _fit_name(name: str, max_len: int) -> str:
    name = str(name)
    if len(name) <= max_len:
        return name
    if max_len <= 1:
        return name[:max_len]
    return name[:max_len - 1] + '…'


def build_resource_message(emoji: str, kind: str, project: str,
                           name: str, provider: str, status: str,
                           when: str = None) -> str:
    if when and len(when) == 5 and ':' in when:
        t = when
    else:
        t = jdatetime.datetime.now().strftime('%H:%M')

    line1 = f"{emoji} {kind} {project}".strip()
    name = str(name)
    limit = EFFECTIVE_MAX

    l3_options = [f"{status} ({t})", f"{status} {t}", status]
    l2_options = [f"{name} ({provider})", name] if provider else [name]

    for l3 in l3_options:
        for l2 in l2_options:
            if len(line1) + len(l2) + len(l3) + 2 <= limit:
                return f"{line1}\n{l2}\n{l3}"

    l3 = f"{status} {t}"
    room = limit - (len(line1) + len(l3) + 2)
    if room < 4:
        l3 = status
        room = limit - (len(line1) + len(l3) + 2)
    l2 = _fit_name(name, max(room, 1))
    return f"{line1}\n{l2}\n{l3}"


def _load_tracker() -> dict:
    try:
        if not os.path.exists(TRACKER_FILE):
            return {}
        with open(TRACKER_FILE, 'r', encoding='utf-8') as f:
            fcntl.flock(f, fcntl.LOCK_SH)
            content = f.read()
            fcntl.flock(f, fcntl.LOCK_UN)
        return json.loads(content) if content.strip() else {}
    except Exception:
        return {}


def _save_tracker(data: dict):
    try:
        tmp_path = TRACKER_FILE + '.tmp'
        with open(tmp_path, 'w', encoding='utf-8') as f:
            fcntl.flock(f, fcntl.LOCK_EX)
            json.dump(data, f, ensure_ascii=False, indent=2)
            f.flush()
            os.fsync(f.fileno())
            fcntl.flock(f, fcntl.LOCK_UN)
        os.replace(tmp_path, TRACKER_FILE)
    except Exception as e:
        logger.error(f"[SMS] خطا در ذخیره وضعیت: {e}")


def summarize_error(error_message: str) -> str:
    if not error_message:
        return "خطا"
    msg = str(error_message).strip()
    low = msg.lower()

    m = re.search(r'http\s*(\d{3})', low)
    if m:
        return f"HTTP {m.group(1)}"

    patterns = [
        (r'timeout|timed\sout', 'تایم‌اوت'),
        (r'connection\srefused|connection\sreset', 'قطع ارتباط'),
        (r'dns|getaddrinfo', 'خطای DNS'),
        (r'ssl|certificate', 'خطای SSL'),
        (r'bucket\s+\S+\s+not found', 'باکت یافت نشد'),
        (r'access\s*denied', 'دسترسی غیرمجاز'),
    ]
    for pattern, short_msg in patterns:
        if re.search(pattern, low):
            return short_msg

    if len(msg) <= 30:
        return msg
    return msg[:27] + "..."


def sanitize_sms_text(text: str) -> str:
    """خنثی‌سازی لینک‌ها برای عبور از فیلتر اپراتور"""
    if not text:
        return text
    # حذف پروتکل لینک
    text = re.sub(r'https?://', '', text, flags=re.IGNORECASE)
    # جدا کردن نقطه‌های IP
    text = re.sub(r'\b(?:\d{1,3}\.){3}\d{1,3}\b',
                  lambda m: m.group(0).replace('.', ' '), text)
    # ⚠️ regex قبلی حذف شد — متن را تخریب می‌کرد:
    # text = re.sub(r'(?<=[A-Za-z0-9-_]).(?=[A-Za-z]{2,})', ' ', text)  ← حذف
    return text


def _gregorian_to_jalali(gy: int, gm: int, gd: int):
    """تبدیل تاریخ میلادی به شمسی (الگوریتم استاندارد دقیق)"""
    g_d_m = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
    gy2 = gy + 1 if gm > 2 else gy
    days = (355666 + (365 * gy) + ((gy2 + 3) // 4) - ((gy2 + 99) // 100)
            + ((gy2 + 399) // 400) + gd + g_d_m[gm - 1])
    jy = -1595 + (33 * (days // 12053))
    days %= 12053
    jy += 4 * (days // 1461)
    days %= 1461
    if days > 365:
        jy += (days - 1) // 365
        days = (days - 1) % 365
    if days < 186:
        jm = 1 + (days // 31)
        jd = 1 + (days % 31)
    else:
        jm = 7 + ((days - 186) // 30)
        jd = 1 + ((days - 186) % 30)
    return jy, jm, jd


def _convert_miladi_to_shamsi_in_text(text: str) -> str:
    """تبدیل خودکار تاریخ‌های میلادی (YYYY-MM-DD یا YYYY/MM/DD) در متن به شمسی"""
    if not text:
        return text
    
    # الگوی تاریخ میلادی: 2026-09-29 یا 2026/09/29
    miladi_pattern = r'\b(19\d{2}|20\d{2})[-/](\d{1,2})[-/](\d{1,2})\b'
    
    def replace_date(match):
        gy = int(match.group(1))
        gm = int(match.group(2))
        gd = int(match.group(3))
        try:
            jy, jm, jd = _gregorian_to_jalali(gy, gm, gd)
            return f"{jy}/{jm:02d}/{jd:02d}"
        except Exception:
            return match.group(0)  # در صورت خطا، تاریخ اصلی را برگردان
    
    return re.sub(miladi_pattern, replace_date, text)


class SMSService:
    _ERROR_CODES = {
        0: "موفق", 1: "API Key نامعتبر", 2: "کاربر مسدود", 3: "شماره ارسال‌کننده نامعتبر",
        4: "محدودیت روزانه", 5: "بیش از ۱۰۰ گیرنده", 6: "خط غیرفعال", 7: "کلمات فیلترشده",
        8: "موجودی کافی نیست", 9: "به‌روزرسانی سامانه", 10: "وب‌سرویس غیرفعال",
        15: "ارسال تکراری", 16: "شماره گیرنده یافت نشد", 18: "فقط ارسال تکی مجاز",
        19: "عدم تطابق با الگو", 21: "IP مجاز نیست", 22: "کارت ملی تأیید نشده",
    }

    def __init__(self, api_key: str, line_number: str, alert_phones: List[str]):
        self.api_key = api_key
        self.line_number = line_number
        self.alert_phones = alert_phones if isinstance(alert_phones, list) else [alert_phones]
        self.url = "https://api.payamakapi.ir/api/v1/SMS/Send"

    def _send_sms(self, mobile: str, message_text: str) -> bool:
        message_text = _convert_miladi_to_shamsi_in_text(message_text)
        message_text = sanitize_sms_text(message_text)
        if len(message_text) > EFFECTIVE_MAX:
            message_text = message_text[:EFFECTIVE_MAX - 3] + "..."

        headers = {
            "X-API-KEY": self.api_key,
            "Content-Type": "application/json",
            "Accept": "application/json",
        }
        payload = {
            "From": self.line_number,
            "ToNumber": mobile,
            "Content": message_text,
        }
        try:
            response = requests.post(self.url, json=payload, headers=headers, timeout=15)
            if response.status_code != 200:
                print(f"[SMS] ❌ HTTP {response.status_code} به {mobile} | {response.text[:200]}")
                return False
            try:
                data = response.json()
            except Exception:
                data = {}
            if is_send_success(data):
                return True
            code = data.get("resultCode")
            reason = self._ERROR_CODES.get(code, f"resultCode={code}")
            print(f"[SMS] ❌ خطای API به {mobile} | {reason} | پاسخ: {response.text[:200]}")
            return False
        except requests.exceptions.Timeout:
            print(f"[SMS] ❌ Timeout برای {mobile}")
            return False
        except requests.exceptions.ConnectionError:
            print(f"[SMS] ❌ خطای اتصال به {self.url}")
            return False
        except Exception as e:
            print(f"[SMS] ❌ خطای غیرمنتظره برای {mobile}: {e}")
            return False

    def check_and_send_alert(self, service_name: str, service_status: str, error_details=None) -> bool:
        service_name = str(service_name).strip()
        tracker = _load_tracker()
        st = tracker.get(service_name)
        if not isinstance(st, dict) or \
           'failure_count' not in st or \
           'success_count' not in st or \
           'last_alert_sent' not in st:
            st = {'failure_count': 0, 'success_count': 0, 'last_alert_sent': None}
        tracker[service_name] = st

        sms_sent = False
        if service_status == "down":
            st['failure_count'] += 1
            st['success_count'] = 0
            if st['failure_count'] >= FAILURE_THRESHOLD and st['last_alert_sent'] != 'down':
                err = summarize_error(error_details)
                t = datetime.now().strftime("%H:%M")
                message = f"🚨 سرویس\n{service_name}\nقطعی: {err} ({t})"
                for phone in self.alert_phones:
                    if self._send_sms(phone, message): sms_sent = True
                st['last_alert_sent'] = 'down'
        elif service_status == "up":
            st['success_count'] += 1
            st['failure_count'] = 0
            if st['success_count'] >= SUCCESS_THRESHOLD and st['last_alert_sent'] == 'down':
                t = datetime.now().strftime("%H:%M")
                message = f"✅ سرویس\n{service_name}\nفعال شد ({t})"
                for phone in self.alert_phones:
                    if self._send_sms(phone, message): sms_sent = True
                st['last_alert_sent'] = 'up'

        tracker[service_name] = st
        _save_tracker(tracker)
        return sms_sent

    def send_custom_alert(self, message_text: str) -> bool:
        success = False
        for phone in self.alert_phones:
            if self._send_sms(phone, message_text): success = True
        return success


def setup_sms_service(api_key: str, line_number: str, alert_phones: List[str]) -> SMSService:
    return SMSService(api_key, line_number, alert_phones)