import os
import secrets
from functools import wraps

from flask import Flask, abort, current_app, flash, g, redirect, request, session, url_for

from . import money
from .db import close_db, q, upgrade
from .i18n import get_lang, nm, t
from .modules import MODULES, License

ROLES = ("admin", "accountant", "viewer")


def login_required(view):
    @wraps(view)
    def wrapped(*args, **kwargs):
        if g.user is None:
            return redirect(url_for("auth.login", next=request.path))
        return view(*args, **kwargs)
    return wrapped


def role_required(*roles):
    def deco(view):
        @wraps(view)
        def wrapped(*args, **kwargs):
            if g.user is None:
                return redirect(url_for("auth.login"))
            if g.user["role"] not in roles:
                flash(t("You do not have permission for this action."), "error")
                return redirect(request.referrer or url_for("home.index"))
            if license_info().read_only and request.method == "POST":
                flash(t("The license has expired or is invalid. The system is read-only."), "error")
                return redirect(request.referrer or url_for("home.index"))
            return view(*args, **kwargs)
        return wrapped
    return deco


write_required = role_required("admin", "accountant")
admin_required = role_required("admin")

# ---------------------------------------------------------------- levels above the roles
# prime: the software provider (you). Hidden from the customer; created only from the server (manage.py).
# super: the customer's IT. Manages users; anything else only when the provider grants it.
GRANTABLE = {"modules": "Change modules and type of business", "branches": "Add branches", "backup": "Backups"}


def user_level():
    return (g.user["level"] or "") if g.get("user") is not None and "level" in g.user.keys() else ""


def is_prime():
    return user_level() == "prime"


def is_super():
    return user_level() in ("super", "prime")


def prime_grants():
    if "prime_grants" not in g:
        try:
            row = q("SELECT prime_grants FROM company WHERE id = 1", one=True)
            g.prime_grants = set((row["prime_grants"] or "").split(",")) - {""} if row else set()
        except Exception:
            g.prime_grants = set()
    return g.prime_grants


def can(perm):
    """Prime can do everything; the customer's super admin only what the provider granted."""
    if is_prime():
        return True
    return user_level() == "super" and perm in prime_grants()


def level_required(check, message="This needs the system administrator."):
    def deco(view):
        @wraps(view)
        def wrapped(*args, **kwargs):
            if g.user is None:
                return redirect(url_for("auth.login"))
            if not check():
                flash(t(message), "error")
                return redirect(request.referrer or url_for("home.index"))
            return view(*args, **kwargs)
        return wrapped
    return deco


prime_required = level_required(is_prime, "Only the software provider can do this.")
super_required = level_required(is_super, "Only the system administrator (IT) can manage users.")


def perm_required(perm):
    return level_required(lambda: can(perm), "Only the software provider can do this. Ask them to give you access.")


def license_info():
    return current_app.config["LICENSE"]


def enabled_modules():
    """Modules this company has switched on (Settings > License & Modules), or None for every licensed one."""
    if "enabled_modules" not in g:
        try:
            row = q("SELECT enabled_modules FROM company WHERE id = 1", one=True)
            g.enabled_modules = set(row["enabled_modules"].split(",")) if row and row["enabled_modules"] else None
        except Exception:  # before the migration has run
            g.enabled_modules = None
    return g.enabled_modules


def has(module):
    """Licensed AND switched on for this company's type of business. Core accounting is always on."""
    if current_app.config.get("ALL_MODULES"):  # seeding demo data
        return True
    if module not in license_info().modules:
        return False
    on = enabled_modules()
    return on is None or module == "accounting" or module in on


def module_required(*modules):
    """Blueprint guard: the page needs at least one of these licensed modules."""
    def guard():
        if not any(has(m) for m in modules):
            flash(t("This module is not included in your license."), "error")
            return redirect(url_for("home.index"))
    return guard


def can_approve():
    u = g.get("user")
    return u is not None and (u["role"] == "admin" or bool(u["can_approve"]))


def allowed_branches():
    """Active branches the current user may see."""
    if "allowed_branches" not in g:
        u = g.user
        if u is None:
            g.allowed_branches = []
        elif u["role"] == "admin" or u["all_branches"]:
            g.allowed_branches = q("SELECT * FROM branches WHERE active = 1 ORDER BY code")
        else:
            g.allowed_branches = q("SELECT b.* FROM branches b JOIN user_branches ub ON ub.branch_id = b.id "
                                   "WHERE ub.user_id = ? AND b.active = 1 ORDER BY b.code", (u["id"],))
    return g.allowed_branches


def allowed_branch_ids():
    return [b["id"] for b in allowed_branches()]


def context_branch_ids():
    """Branches selected in the top bar switcher ('all' = every allowed branch)."""
    sel = session.get("branch", "all")
    ids = allowed_branch_ids()
    if sel != "all":
        try:
            if int(sel) in ids:
                return [int(sel)]
        except ValueError:
            pass
    return ids


def check_branch(branch_id):
    try:
        bid = int(branch_id)
    except (TypeError, ValueError):
        abort(400)
    if bid not in allowed_branch_ids():
        abort(403)
    return bid


def currency_decimals(code):
    if "cur_dec" not in g:
        g.cur_dec = {r["code"]: r["decimals"] for r in q("SELECT code, decimals FROM currencies")}
    return g.cur_dec.get(code, 2)


def create_app(database=None, license_path=None):
    app = Flask(__name__)
    base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    instance = os.path.join(base, "instance")
    os.makedirs(instance, exist_ok=True)
    key_file = os.path.join(instance, "secret.key")
    if not os.path.exists(key_file):
        with open(key_file, "w") as f:
            f.write(secrets.token_hex(32))
    with open(key_file) as f:
        secret = f.read().strip()
    from datetime import timedelta
    https = os.environ.get("VERTEX_HTTPS") == "1"
    app.config.update(SECRET_KEY=secret, DATABASE=database or os.path.join(instance, "vertex.db"),
                      MAX_CONTENT_LENGTH=64 * 1024 * 1024, CSRF_ENABLED=True,
                      SESSION_COOKIE_HTTPONLY=True, SESSION_COOKIE_SAMESITE="Lax", SESSION_COOKIE_SECURE=https,
                      PERMANENT_SESSION_LIFETIME=timedelta(hours=int(os.environ.get("VERTEX_SESSION_HOURS", "8"))))
    from datetime import datetime as _dt
    app.config["STARTED_AT"] = _dt.now().isoformat(timespec="seconds")
    app.config["LICENSE"] = License(license_path or os.path.join(instance, "license.json"))
    if os.environ.get("VERTEX_BEHIND_PROXY") == "1":  # behind nginx / Cloudflare Tunnel: trust one proxy hop
        from werkzeug.middleware.proxy_fix import ProxyFix
        app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1)
    app.teardown_appcontext(close_db)
    if os.path.exists(app.config["DATABASE"]):
        upgrade(app.config["DATABASE"])

    @app.before_request
    def csrf_protect():
        """Every form and script POST carries the session's token (the supplier pages check their own)."""
        if request.method != "POST" or not app.config.get("CSRF_ENABLED") or request.blueprint == "supplier":
            return None
        sent = request.form.get("csrf") or request.headers.get("X-CSRF-Token", "")
        if not sent or not secrets.compare_digest(sent, session.get("csrf", "")):
            if request.is_json:
                from flask import jsonify
                return jsonify(ok=False, error=t("The page expired. Reload it and try again.")), 400
            flash(t("The form expired. Please try again."), "error")
            ref = request.referrer or ""
            return redirect(ref if ref.startswith(request.host_url) else url_for("home.index"))
        return None

    form_tag = __import__("re").compile(r'(<form\b[^>]*\bmethod="post"[^>]*>)', __import__("re").I)

    @app.after_request
    def csrf_fields(resp):
        """Also write the token into every POST form of the page (works without JavaScript)."""
        if resp.mimetype == "text/html" and not resp.direct_passthrough and "csrf" in session \
                and request.blueprint != "supplier":
            html = resp.get_data(as_text=True)
            field = f'<input type="hidden" name="csrf" value="{session["csrf"]}">'
            new = form_tag.sub(lambda m: m.group(1) + field, html)
            if new != html:
                resp.set_data(new)
        return resp

    import re
    title_re = re.compile(r"<title>(.*?) · ", re.S)

    @app.after_request
    def remember_recent(resp):
        """Record pages of one document or record (a number in the address) go into the user's recently viewed."""
        try:
            if request.method != "GET" or resp.status_code != 200 or resp.mimetype != "text/html" \
                    or resp.direct_passthrough or not g.get("user") or request.args.get("export"):
                return resp
            args = request.view_args or {}
            if not any(isinstance(v, int) for v in args.values()) and not \
                    (request.endpoint == "setup.form_view" and args.get("key")):
                return resp
            if (request.blueprint or "") in ("code", "attachments", "ux", "portal", "supplier", "vendorportal") \
                    or "print" in (request.endpoint or ""):
                return resp
            m = title_re.search(resp.get_data(as_text=True)[:3000])
            if not m:
                return resp
            import html as _html
            title = _html.unescape(m.group(1)).strip()[:120]
            from .apps import page_hint
            from .db import commit as _commit, x as _x
            from .ledger import now as _now
            url = request.path + (("?type=" + request.args["type"]) if request.args.get("type") in ("customer", "vendor") else "")
            _x("INSERT INTO recent_views (user_id, url, title, app, at) VALUES (?,?,?,?,?) ON CONFLICT (user_id, url) "
               "DO UPDATE SET title = excluded.title, app = COALESCE(excluded.app, app), at = excluded.at",
               (g.user["id"], url, title, page_hint(), _now()))
            _x("DELETE FROM recent_views WHERE user_id = ? AND url NOT IN (SELECT url FROM recent_views WHERE user_id = ? "
               "ORDER BY at DESC LIMIT 30)", (g.user["id"], g.user["id"]))
            _commit()
        except Exception:  # never let the history break a page
            pass
        return resp

    @app.after_request
    def security_headers(resp):
        resp.headers.setdefault("X-Content-Type-Options", "nosniff")
        resp.headers.setdefault("X-Frame-Options", "SAMEORIGIN")
        resp.headers.setdefault("Referrer-Policy", "same-origin")
        if https:
            resp.headers.setdefault("Strict-Transport-Security", "max-age=31536000")
        return resp

    @app.context_processor
    def csrf_context():
        def csrf_token():
            if "csrf" not in session:
                session["csrf"] = secrets.token_urlsafe(24)
            return session["csrf"]
        return {"csrf_token": csrf_token}

    @app.before_request
    def load_user():
        uid = session.get("user_id")
        g.user = q("SELECT * FROM users WHERE id = ? AND active = 1", (uid,), one=True) if uid else None

    def _nav_apps():
        """(apps for the sidebar, key of the app the page belongs to); computed once per request when used."""
        if "nav_apps" not in g:
            from .apps import current_app, visible_apps
            apps = visible_apps()
            g.nav_apps = (apps, current_app(apps))
        return g.nav_apps

    @app.context_processor
    def inject():
        from .ledger import company
        return {
            "t": t, "nm": nm, "lang": get_lang(), "rtl": get_lang() == "ar",
            "user": g.get("user"), "company": company() if g.get("user") else None,
            "nav_branches": allowed_branches() if g.get("user") else [],
            "branch_ctx": session.get("branch", "all"),
            "can_write": g.get("user") is not None and g.user["role"] in ("admin", "accountant"),
            "is_admin": g.get("user") is not None and g.user["role"] == "admin",
            "has": has, "can": can, "is_prime": is_prime(), "is_super": is_super(), "license": license_info(), "can_approve": can_approve() if g.get("user") else False,
            "nav_apps": _nav_apps,
        }

    @app.template_filter("money")
    def money_filter(value, currency=None, blank_zero=False):
        return money.fmt(value, currency_decimals(currency) if currency else 2, blank_zero)

    from datetime import date
    from .attachments import listing as attachments_for

    def _credit_issues(partner_id, amount, currency):
        from .credit import issues
        return issues(partner_id, amount, currency)
    def export_url(kind):
        """This page with ?export=<kind> (keeping its filters)."""
        args = dict(request.view_args or {})
        args.update(request.args.to_dict())
        args["export"] = kind
        return url_for(request.endpoint, **args)
    def approval_status(doc_type, doc_id):
        from .workflow import status
        return status(doc_type, doc_id, g.user["id"] if g.get("user") else None)

    def approvals_waiting():
        if not g.get("user"):
            return 0
        if "approvals_waiting" not in g:
            from .workflow import inbox, unread_count
            g.approvals_waiting = (len(inbox(g.user["id"])), unread_count(g.user["id"]))
        return g.approvals_waiting
    def terms_for(doc_type):
        from .workflow import terms_options
        return terms_options(doc_type)
    def args_with(**changes):
        """This page's URL with its current filters and search kept, and some arguments changed ('' removes one)."""
        args = request.args.to_dict(flat=False)
        for k, v in changes.items():
            if v in (None, ""):
                args.pop(k, None)
            else:
                args[k] = [v]
        return url_for(request.endpoint, **(request.view_args or {}), **args)

    def kept_args(*skip):
        """Hidden fields for the current URL arguments a filter form does not have itself (tabs, type...)."""
        out = []
        for k, vals in request.args.to_dict(flat=False).items():
            if k in skip:
                continue
            for v in vals:
                out.append((k, v))
        return out
    def partner_url(pid, vendor=False):
        """Where a partner's name links to: the vendor page (Vendors module) or the contact form."""
        if not pid:
            return None
        if vendor and has("vendors"):
            return url_for("vendors.view", pid=pid)
        return url_for("setup.form_view", model="partners", key=pid)
    ACTION_LABEL = {"create": "Created", "save": "Saved", "update": "Updated", "post": "Posted", "posted": "Posted",
                    "draft": "Reset to draft", "cancel": "Cancelled", "cancelled": "Cancelled", "attach": "File attached",
                    "detach": "File removed", "approve": "Approved", "reject": "Rejected", "submit": "Submitted for approval",
                    "confirm": "Confirmed", "email": "Emailed", "send": "Sent", "renumber": "Renumbered", "pay": "Payment",
                    "deposit": "Deposited", "clear": "Cleared", "bounce": "Bounced", "register": "Registered",
                    "done": "Validated", "validate": "Validated", "override": "Approved (override)"}

    def chatter_for(model, rid):
        rows = []
        for n in q("SELECT n.*, u.full_name, u.username FROM doc_notes n LEFT JOIN users u ON u.id = n.user_id "
                   "WHERE n.model = ? AND n.record_id = ?", (model, rid)):
            rows.append({"ts": n["ts"], "who": n["full_name"] or n["username"] or "", "note": n["body"]})
        for a in q("SELECT a.*, u.full_name, u.username FROM audit_log a LEFT JOIN users u ON u.id = a.user_id "
                   "WHERE a.model = ? AND a.record_id = ?", (model, rid)):
            rows.append({"ts": a["ts"] or "", "who": a["full_name"] or a["username"] or t("System"),
                         "action": t(ACTION_LABEL.get(a["action"], a["action"].replace("_", " ").capitalize())),
                         "details": a["details"] or ""})
        rows.sort(key=lambda r: r["ts"], reverse=True)
        return rows
    def favorites_here():
        from .views.ux import favorites
        return favorites(request.path)

    def recent_views(limit=12):
        if not g.get("user"):
            return []
        from .apps import APPS
        labels = {a[0]: a[1] for a in APPS}
        off = {a[0] for a in APPS if a[5] and not has(a[5])}  # apps no longer licensed or switched off
        rows = [dict(r, app_label=labels.get(r["app"])) for r in q(
            "SELECT url, title, app, at FROM recent_views WHERE user_id = ? AND url != ? ORDER BY at DESC LIMIT ?",
            (g.user["id"], request.path, limit + 10)) if r["app"] not in off]
        return rows[:limit]
    app.jinja_env.globals.update(args_with=args_with, kept_args=kept_args, partner_url=partner_url, chatter_for=chatter_for,
                                 favorites_here=favorites_here, recent_views=recent_views)
    app.jinja_env.globals.update(terms_for=terms_for, approval_status=approval_status, approvals_waiting=approvals_waiting,
                                 export_url=export_url, cur_dec=currency_decimals, today_iso=lambda: date.today().isoformat(),
                                 attachments_for=attachments_for, credit_issues=_credit_issues)

    @app.template_filter("plain")
    def plain_filter(value, currency=None):
        return money.plain(value, currency_decimals(currency) if currency else 2)

    from .views import assets, auth, dashboard, entries, inventory, invoices, orders, payments, prepaid, \
        procurement, reports, setup, transfers, vendors, closing, crm, pos, bank, imports, home, attachments, \
        statements, recurring, credit, budgets, hr, fx, cheques, pettycash, wtransfers, workflow, projects, supplier, codeedit, ux, insights
    for bp in (auth.bp, home.bp, dashboard.bp, attachments.bp, statements.bp, recurring.bp, credit.bp, budgets.bp, entries.bp, invoices.bp, payments.bp, reports.bp, setup.bp, transfers.bp,
               orders.bp, inventory.bp, procurement.bp, vendors.bp, assets.bp, prepaid.bp, closing.bp, crm.bp,
               pos.bp, bank.bp, imports.bp, hr.bp, fx.bp, cheques.bp, pettycash.bp, wtransfers.bp, workflow.bp, projects.bp, supplier.bp, codeedit.bp, ux.bp, insights.bp):
        app.register_blueprint(bp)

    @app.errorhandler(413)
    def too_large(_e):
        flash(t("The upload is too large."), "error")
        return redirect(request.referrer or url_for("home.index"))

    @app.errorhandler(403)
    def forbidden(_e):
        flash(t("You do not have access to this branch."), "error")
        return redirect(url_for("home.index"))

    return app
