import json, subprocess, hashlib, os, uuid
from datetime import datetime, timezone
from flask import session

CONFIGS_DIR        = '/routlin_location'
DATA_DIR           = '/data'
ACCOUNTS_FILE      = f'{DATA_DIR}/authorized_accounts.json'
CORE_FILE          = f'{CONFIGS_DIR}/core.json'
DASHBOARD_QUEUE    = f'{CONFIGS_DIR}/.dashboard-queue'
DASHBOARD_DONE     = f'{CONFIGS_DIR}/.dashboard-done'
DASHBOARD_LAST_RUN = f'{CONFIGS_DIR}/.dashboard-last-run'
DASHBOARD_LOCK     = f'{CONFIGS_DIR}/.dashboard-lock'
DASHBOARD_PENDING  = f'{CONFIGS_DIR}/.dashboard-pending'
HEALTH_FILE        = f'{CONFIGS_DIR}/.health'
PRODUCT_NAME          = os.environ.get('PRODUCT_NAME', 'routlin')
DASHB_TIMER_NAME      = f'{PRODUCT_NAME}-dashboard-queue'
DDNS_TIMER_NAME       = f'{PRODUCT_NAME}-ddns-update'
WEB_APP_DISPLAY_NAME  = os.environ.get('WEB_APP_DISPLAY_NAME', f'{PRODUCT_NAME.capitalize()} Dashboard')
DASHB_INTERVAL_SECS = 60
QUEUE_MAX_LINES    = 50


def load_core():
    try:
        with open(CORE_FILE) as f:
            return json.load(f)
    except Exception:
        return {}


def save_core(data):
    with open(CORE_FILE, 'w') as f:
        json.dump(data, f, indent=2)


def core_hash():
    try:
        with open(CORE_FILE, 'rb') as f:
            return hashlib.md5(f.read()).hexdigest()
    except Exception:
        return ''


def verify_core_hash(submitted):
    if not submitted:
        return True
    return submitted == core_hash()


def _load_done_set():
    try:
        done = set()
        for line in open(DASHBOARD_DONE).read().splitlines():
            parts = line.split()
            if parts:
                done.add(parts[0])
        return done
    except Exception:
        return set()


def _read_pending(done_set):
    pending = []
    try:
        lines = open(DASHBOARD_QUEUE).read().splitlines()
    except Exception:
        return pending
    for line in lines:
        try:
            parts = line.split(None, 3)
            if len(parts) == 4:
                entry_uuid, entry_ts, _dt, rest = parts
                cmd_user = rest.rsplit(' (', 1)
                entry_cmd  = cmd_user[0].strip('[]')
                entry_user = cmd_user[1].rstrip(')') if len(cmd_user) == 2 else ''
                if entry_uuid not in done_set:
                    pending.append((entry_uuid, int(entry_ts), entry_cmd, entry_user))
        except Exception:
            pass
    return pending


def get_pending_entries():
    return _read_pending(_load_done_set())


def _format_timing(secs):
    if secs is None:
        return None
    if secs <= 5:
        return 'momentarily'
    if secs < 60:
        return f'in about {secs} seconds'
    mins = round(secs / 60)
    return f'in about {mins} minute{"s" if mins != 1 else ""}'


def _trim_if_needed():
    try:
        lines = [l for l in open(DASHBOARD_QUEUE).read().splitlines() if l]
        if len(lines) <= QUEUE_MAX_LINES:
            return
        done_set = _load_done_set()
        pending = [l for l in lines if l.split()[0] not in done_set]
        with open(DASHBOARD_QUEUE, 'w') as f:
            f.write('\n'.join(pending) + ('\n' if pending else ''))
        open(DASHBOARD_DONE, 'w').close()
    except Exception:
        pass


def _apply_on_save():
    try:
        return load_core().get('network_interfaces', {}).get('apply_on_save', True)
    except Exception:
        return True


def _read_dashboard_pending():
    """Return list of (uuid, ts, cmd, user, description) from .dashboard-pending."""
    items = []
    try:
        lines = open(DASHBOARD_PENDING).read().splitlines()
    except Exception:
        return items
    for line in lines:
        if not line.strip():
            continue
        try:
            main, _, desc = line.partition(' :: ')
            parts = main.split(None, 3)
            if len(parts) == 4:
                entry_uuid, entry_ts, _dt, rest = parts
                cmd_user   = rest.rsplit(' (', 1)
                entry_cmd  = cmd_user[0].strip('[]')
                entry_user = cmd_user[1].rstrip(')') if len(cmd_user) == 2 else ''
                items.append((entry_uuid, int(entry_ts), entry_cmd, entry_user, desc))
        except Exception:
            pass
    return items


def get_dashboard_pending():
    return _read_dashboard_pending()


def flush_pending_to_queue():
    """Move all entries from .dashboard-pending to .dashboard-queue and clear pending."""
    items = _read_dashboard_pending()
    if not items:
        return
    done_set = _load_done_set()
    existing_ids = {uu for uu, *_ in _read_pending(done_set)}
    with open(DASHBOARD_QUEUE, 'a') as f:
        for entry_uuid, entry_ts, entry_cmd, entry_user, _desc in items:
            if entry_uuid not in existing_ids:
                dt_str = datetime.fromtimestamp(entry_ts).strftime('%Y-%m-%dT%H:%M:%S')
                f.write(f'{entry_uuid} {entry_ts} {dt_str} [{entry_cmd}] ({entry_user})\n')
    open(DASHBOARD_PENDING, 'w').close()
    _trim_if_needed()


def _queue_pending_command(cmd, description=''):
    """Append cmd to .dashboard-pending if not already present for this cmd+user."""
    existing = _read_dashboard_pending()
    current_user = session.get('email_address', 'unknown')
    for entry_uuid, entry_ts, entry_cmd, entry_user, _desc in existing:
        if entry_cmd == cmd and entry_user == current_user:
            return entry_uuid, entry_ts
    entry_uuid = str(uuid.uuid4())
    now = datetime.now()
    entry_ts = int(now.timestamp())
    dt_str = now.strftime('%Y-%m-%dT%H:%M:%S')
    desc_suffix = f' :: {description}' if description else ''
    with open(DASHBOARD_PENDING, 'a') as f:
        f.write(f'{entry_uuid} {entry_ts} {dt_str} [{cmd}] ({current_user}){desc_suffix}\n')
    return entry_uuid, entry_ts


def _queue_command(cmd, description=''):
    if not _apply_on_save():
        return _queue_pending_command(cmd, description)
    done_set = _load_done_set()
    pending = _read_pending(done_set)
    current_user = session.get('email_address', 'unknown')
    for entry_uuid, entry_ts, entry_cmd, entry_user in pending:
        if entry_cmd == cmd and entry_user == current_user:
            return entry_uuid, entry_ts
    entry_uuid = str(uuid.uuid4())
    now = datetime.now()
    entry_ts = int(now.timestamp())
    dt_str = now.strftime('%Y-%m-%dT%H:%M:%S')
    user = session.get('email_address', 'unknown')
    with open(DASHBOARD_QUEUE, 'a') as f:
        f.write(f'{entry_uuid} {entry_ts} {dt_str} [{cmd}] ({user})\n')
    _trim_if_needed()
    return entry_uuid, entry_ts


def _entry_ts_from_queue(entry_uuid):
    try:
        for line in open(DASHBOARD_QUEUE).read().splitlines():
            parts = line.split(None, 2)
            if len(parts) >= 2 and parts[0] == entry_uuid:
                return int(parts[1])
    except Exception:
        pass
    return None


def _seconds_until_next_run():
    try:
        last_run = float(open(DASHBOARD_LAST_RUN).read().strip())
        elapsed = datetime.now(timezone.utc).timestamp() - last_run
        return int(max(0, DASHB_INTERVAL_SECS - elapsed))
    except Exception:
        return None


def _is_locked():
    try:
        return os.path.getsize(DASHBOARD_LOCK) > 0
    except Exception:
        return False


def _lock_mtime():
    try:
        return os.path.getmtime(DASHBOARD_LOCK)
    except Exception:
        return None


def queue_command(cmd, description=''):
    """Queue a command without generating a flash message."""
    return _queue_command(cmd, description)


def queued_msg(cmd=None, description='', action_label='Configuration saved'):
    """Queue cmd if given, then return a timing message.
    Without cmd, just returns timing (for commands already queued by the caller).
    action_label replaces the 'Configuration saved' prefix for non-save actions."""
    entry_ts = None
    if cmd is not None:
        _entry_uuid, entry_ts = queue_command(cmd, description)
    if not _apply_on_save():
        return f'{action_label}. Click Apply Now on the Configuration Changes card to apply.'
    if _is_locked():
        mtime = _lock_mtime()
        if entry_ts is not None and mtime and entry_ts < mtime:
            return f'{action_label}. Changes are being applied now.'
        return f'{action_label}. Changes will be applied on the next run.'
    timing = _format_timing(_seconds_until_next_run())
    if timing:
        return f'{action_label}. Changes will be applied {timing}.'
    if cmd is None:
        return f'{action_label}. The processing service is not running.'
    parts = cmd.split()
    cli_cmd     = f'sudo python3 {parts[0]}.py --{parts[1]}' if len(parts) == 2 else cmd
    install_cmd = f'sudo python3 install.py'
    from markupsafe import Markup
    return Markup(f'{action_label}. The command processing service is not installed. '
                  f'Run <strong>{install_cmd}</strong> to enable it, '
                  f'or <strong>{cli_cmd}</strong> to apply manually.')


def run_apply():
    try:
        subprocess.run(
            ['python3', f'{CONFIGS_DIR}/core.py', '--apply'],
            capture_output=True, timeout=30
        )
    except Exception:
        pass


def run_update_blocklists():
    try:
        subprocess.run(
            ['python3', f'{CONFIGS_DIR}/core.py', '--update-blocklists'],
            capture_output=True, timeout=120
        )
    except Exception:
        pass