"""Public pages for suppliers: the registration link, the form to correct a registration, account activation, and
the vendor portal (sign in, home). Separate from staff sign-in: a portal session never opens staff pages."""
import secrets
from datetime import date, timedelta

from flask import Blueprint, abort, flash, g, redirect, render_template, request, session, url_for

from .. import has
from ..db import commit, get_db, q
from ..i18n import t
from ..ledger import AccountingError, company
from .. import portal
from .. import vendorportal as vp
from ..money import to_int

bp = Blueprint("supplier", __name__)


@bp.before_request
def guard():
    if not has("portal"):
        abort(404)
    g.portal_user = None
    pu = session.get("portal_user")
    if pu:
        g.portal_user = q("SELECT pu.*, p.name_en, p.name_ar, p.vendor_status FROM portal_users pu JOIN partners p "
                          "ON p.id = pu.partner_id WHERE pu.id = ? AND pu.active = 1 AND p.active = 1", (pu,), one=True)
    if request.method == "POST":
        sent = request.form.get("csrf", "")
        if not sent or not secrets.compare_digest(sent, session.get("csrf", "")):
            flash(t("The form expired. Please try again."), "error")
            return redirect(request.path)


def portal_required(view):
    from functools import wraps

    @wraps(view)
    def wrapped(*a, **kw):
        if not g.portal_user:
            return redirect(url_for("supplier.login"))
        return view(*a, **kw)
    return wrapped


def form_docs():
    """Documents sent with the form: doc_type_N, number_N, expiry_N, file_N."""
    out = []
    for i in range(1, 9):
        f = request.files.get(f"file_{i}")
        if f and f.filename:
            out.append((request.form.get(f"doc_type_{i}") or "Other", (request.form.get(f"number_{i}") or "").strip() or None,
                        request.form.get(f"expiry_{i}") or None, f))
    return out


def render_form(reg=None, token=None, info=None, docs=()):
    return render_template("portal/register.html", reg=reg or {}, token=token, info=info, docs=docs,
                           doc_types=portal.DOC_TYPES, required=portal.REQUIRED_DOCS, co=company(),
                           categories=sorted({r[0] for r in q("SELECT DISTINCT vendor_category FROM partners "
                                                              "WHERE vendor_category IS NOT NULL")}))


@bp.route("/supplier/register", methods=["GET", "POST"])
def register():
    if request.method == "POST":
        if request.form.get("website2"):  # hidden field only robots fill in
            return redirect(url_for("supplier.thanks"))
        try:
            vals = portal.clean(request.form)
            rid = portal.register(vals, form_docs(), request.headers.get("X-Forwarded-For", request.remote_addr))
            commit()
            session["reg_number"] = portal.get(rid)["number"]
            return redirect(url_for("supplier.thanks"))
        except AccountingError as e:
            get_db().rollback()
            flash(str(e), "error")
            return render_form(dict(request.form.items()))
    return render_form()


@bp.route("/supplier/register/<token>", methods=["GET", "POST"])
def register_edit(token):
    reg = portal.by_edit_token(token)
    if not reg:
        return render_template("portal/message.html", co=company(), title=t("This link is no longer valid."),
                               text=t("Please contact our procurement team."))
    docs = q("SELECT * FROM vendor_registration_docs WHERE registration_id = ? ORDER BY id", (reg["id"],))
    if request.method == "POST":
        try:
            vals = portal.clean(request.form)
            portal.resubmit(token, vals, form_docs())
            commit()
            session["reg_number"] = reg["number"]
            return redirect(url_for("supplier.thanks"))
        except AccountingError as e:
            get_db().rollback()
            flash(str(e), "error")
            return render_form(dict(request.form.items()), token, reg["info_message"], docs)
    return render_form(dict(reg), token, reg["info_message"], docs)


@bp.route("/supplier/thanks")
def thanks():
    return render_template("portal/message.html", co=company(), title=t("Thank you — your registration was received"),
                           text=(f"{t('Your reference is')} {session.pop('reg_number')}. " if session.get("reg_number") else "")
                           + t("We will review it and email you. Once approved you will receive a link to activate "
                               "your supplier portal account."))


@bp.route("/portal/activate/<token>", methods=["GET", "POST"])
def activate(token):
    u = portal.user_by_activation(token)
    if not u:
        return render_template("portal/message.html", co=company(), title=t("This link is no longer valid."),
                               text=t("Activation links work once and expire after 72 hours. Ask us for a new one."))
    if request.method == "POST":
        try:
            uid = portal.activate(token, request.form.get("password"), request.form.get("confirm"))
            commit()
            session.clear()
            session["portal_user"] = uid
            flash(t("Your account is active."), "success")
            return redirect(url_for("supplier.home"))
        except AccountingError as e:
            get_db().rollback()
            flash(str(e), "error")
    return render_template("portal/activate.html", co=company(), u=u)


@bp.route("/portal/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        try:
            u = portal.login(request.form.get("email"), request.form.get("password"))
            commit()
            if u:
                lang = session.get("lang")
                session.clear()
                session["portal_user"] = u["id"]
                session["lang"] = lang or u["lang"]
                return redirect(url_for("supplier.home"))
            flash(t("Invalid email or password."), "error")
        except AccountingError as e:
            commit()
            flash(str(e), "error")
    return render_template("portal/login.html", co=company())


@bp.route("/portal/forgot", methods=["GET", "POST"])
def forgot():
    """Email a new activation link (choose a new password). Same answer whether or not the address exists."""
    if request.method == "POST":
        from datetime import datetime, timedelta
        email = (request.form.get("email") or "").strip().lower()
        u = q("SELECT pu.* FROM portal_users pu JOIN partners p ON p.id = pu.partner_id WHERE pu.email = ? "
              "AND pu.active = 1 AND p.active = 1 AND p.vendor_status != 'blocked'", (email,), one=True)
        recent = u and u["activation_expires"] and u["activation_expires"] > \
            (datetime.now() + timedelta(hours=portal.ACTIVATION_HOURS) - timedelta(minutes=10)).isoformat(timespec="seconds")
        if u and not recent:
            portal.invite_user(u["partner_id"], u["email"], u["full_name"])
            commit()
        flash(t("If this address has a portal account, we have emailed a link to choose a new password."), "success")
        return redirect(url_for("supplier.login"))
    return render_template("portal/forgot.html", co=company())


@bp.route("/portal/logout")
def logout():
    lang = session.get("lang")
    session.clear()
    if lang:
        session["lang"] = lang
    return redirect(url_for("supplier.login"))


def me():
    return g.portal_user["partner_id"]


def page(template, **kw):
    return render_template(template, co=company(), today=date.today().isoformat(), **kw)


@bp.route("/portal/")
@portal_required
def home():
    pid = me()
    p = q("SELECT * FROM partners WHERE id = ?", (pid,), one=True)
    docs = q("SELECT * FROM vendor_documents WHERE partner_id = ? ORDER BY expiry_date IS NULL, expiry_date", (pid,))
    soon = (date.today() + timedelta(days=30)).isoformat()
    rfqs = [r for r in vp.vendor_rfqs(pid) if r["state"] == "sent" and not r["closed"]]
    orders = [o for o in vp.vendor_orders(pid) if o["state"] == "confirmed" and o["ack_state"] in (None, "awaiting")]
    bills, _ = vp.statement(pid)
    return page("portal/home.html", p=p, docs=docs, soon=soon, open_rfqs=rfqs, open_orders=orders,
                due=sum(b["residual"] for b in bills if b["kind"] == "in_invoice"),
                expiring=[d for d in docs if d["expiry_date"] and d["expiry_date"] <= soon])


@bp.route("/portal/rfqs")
@portal_required
def rfqs():
    return page("portal/rfqs.html", rows=vp.vendor_rfqs(me()))


@bp.route("/portal/rfqs/<int:rfq_id>", methods=["GET", "POST"])
@portal_required
def rfq(rfq_id):
    from ..procurement import closed_for_quotes
    r, rv = vp.rfq_for_vendor(rfq_id, me())
    if not r:
        abort(404)
    lines = q("SELECT * FROM rfq_lines WHERE rfq_id = ? ORDER BY id", (rfq_id,))
    if request.method == "POST":
        fm = request.form
        try:
            prices, taxes, offered, alts = {}, {}, {}, {}
            for ln in lines:
                v = (fm.get(f"price_{ln['id']}") or "").strip()
                prices[ln["id"]] = to_int(v) if v else None
                taxes[ln["id"]] = int(fm[f"tax_{ln['id']}"]) if fm.get(f"tax_{ln['id']}") else None
                offered[ln["id"]] = (fm.get(f"offered_{ln['id']}") or "").strip() or None
                alts[ln["id"]] = fm.get(f"alt_{ln['id']}") == "1"
            vp.submit_bid(rfq_id, me(), g.portal_user["id"], prices, taxes, offered, alts,
                          {"quote_ref": fm.get("quote_ref"), "lead_days": int(fm["lead_days"]) if (fm.get("lead_days") or "").isdigit() else None,
                           "notes": fm.get("notes"), "valid_until": fm.get("valid_until") or None,
                           "payment_terms": fm.get("payment_terms")}, declined=fm.get("action") == "decline")
            commit()
            flash(t("Your quotation was submitted. You can change it until the closing time.") if fm.get("action") != "decline"
                  else t("We have recorded that you will not quote."), "success")
            return redirect(url_for("supplier.rfq", rfq_id=rfq_id))
        except (AccountingError, ValueError) as e:
            get_db().rollback()
            flash(str(e), "error")
    mine = {x["rfq_line_id"]: x for x in q("SELECT * FROM rfq_quotes WHERE rfq_vendor_id = ?", (rv["id"],))}
    files = q("SELECT * FROM attachments WHERE model = 'rfq' AND record_id = ? ORDER BY id", (rfq_id,))
    taxes = q("SELECT * FROM taxes WHERE scope = 'purchase' AND active = 1 ORDER BY rate DESC")
    return page("portal/rfq.html", r=r, rv=rv, lines=lines, mine=mine, files=files, taxes=taxes,
                closed=closed_for_quotes(r), open=r["state"] == "sent" and not closed_for_quotes(r),
                result=vp.result(r, rv["state"]))


@bp.route("/portal/rfqs/<int:rfq_id>/file/<int:att_id>")
@portal_required
def rfq_file(rfq_id, att_id):
    from flask import send_file
    from ..attachments import path
    r, _ = vp.rfq_for_vendor(rfq_id, me())
    att = q("SELECT * FROM attachments WHERE id = ? AND model = 'rfq' AND record_id = ?", (att_id, rfq_id), one=True)
    if not r or not att:
        abort(404)
    return send_file(path(att), download_name=att["filename"], as_attachment=True)


@bp.route("/portal/rfqs/<int:rfq_id>/pdf")
@portal_required
def rfq_pdf(rfq_id):
    from flask import Response
    from ..exports import to_pdf
    from ..procurement import rfq_report
    r, rv = vp.rfq_for_vendor(rfq_id, me())
    if not r:
        abort(404)
    return Response(to_pdf(rfq_report(rfq_id, rv["id"])), mimetype="application/pdf",
                    headers={"Content-Disposition": f"inline; filename={r['number'].replace('/', '-')}.pdf"})


@bp.route("/portal/orders")
@portal_required
def orders():
    return page("portal/orders.html", rows=vp.vendor_orders(me()))


@bp.route("/portal/orders/<int:order_id>", methods=["GET", "POST"])
@portal_required
def order(order_id):
    o = vp.order_for_vendor(order_id, me())
    if not o:
        abort(404)
    if request.args.get("pdf"):
        from flask import Response
        from ..exports import to_pdf
        from ..procurement import po_report
        return Response(to_pdf(po_report(order_id)), mimetype="application/pdf",
                        headers={"Content-Disposition": f"inline; filename={o['number'].replace('/', '-')}.pdf"})
    if request.method == "POST":
        fm = request.form
        try:
            vp.respond_po(order_id, me(), fm.get("ack_state"), fm.get("ack_ref"), fm.get("ack_date") or None,
                          fm.get("ack_note"))
            commit()
            flash(t("Thank you, your response was recorded."), "success")
            return redirect(url_for("supplier.order", order_id=order_id))
        except AccountingError as e:
            get_db().rollback()
            flash(str(e), "error")
    from ..stock import order_progress
    lines = q("SELECT ol.*, p.code, p.uom FROM order_lines ol LEFT JOIN products p ON p.id = ol.product_id "
              "WHERE ol.order_id = ? ORDER BY ol.sequence, ol.id", (order_id,))
    cur = q("SELECT currency FROM branches WHERE id = ?", (o["branch_id"],), one=True)["currency"]
    return page("portal/order.html", o=o, lines=lines, prog=order_progress(order_id), cur=cur)


@bp.route("/portal/invoices", methods=["GET", "POST"])
@portal_required
def invoices():
    pid = me()
    if request.method == "POST":
        fm = request.form
        try:
            untaxed, tax = to_int(fm.get("amount_untaxed") or 0), to_int(fm.get("amount_tax") or 0)
            vals = {"invoice_no": (fm.get("invoice_no") or "").strip(), "invoice_date": fm.get("invoice_date"),
                    "order_id": int(fm["order_id"]) if fm.get("order_id") else None, "amount_untaxed": untaxed,
                    "amount_tax": tax, "amount_total": untaxed + tax, "currency": fm.get("currency") or None,
                    "notes": fm.get("notes")}
            vp.submit_invoice(pid, g.portal_user["id"], vals, request.files.get("file"))
            commit()
            flash(t("Invoice sent. We will let you know when it is processed."), "success")
            return redirect(url_for("supplier.invoices"))
        except (AccountingError, ValueError) as e:
            get_db().rollback()
            flash(str(e), "error")
    rows = [dict(r, status=vp.invoice_status(r)) for r in q(
        "SELECT vi.*, o.number AS po FROM vendor_invoices vi LEFT JOIN orders o ON o.id = vi.order_id "
        "WHERE vi.partner_id = ? ORDER BY vi.id DESC", (pid,))]
    pos = [o for o in vp.vendor_orders(pid) if o["state"] == "confirmed"]
    return page("portal/invoices.html", rows=rows, pos=pos, pre=request.args.get("po", type=int))


@bp.route("/portal/payments")
@portal_required
def payments():
    bills, pays = vp.statement(me())
    return page("portal/payments.html", bills=bills, pays=pays)


@bp.route("/portal/documents", methods=["GET", "POST"])
@portal_required
def documents():
    pid = me()
    if request.method == "POST":
        fm = request.form
        try:
            vp.submit_doc(pid, g.portal_user["id"], fm.get("doc_type"), fm.get("number"), fm.get("expiry_date"),
                          request.files.get("file"))
            commit()
            flash(t("Document sent. It replaces the current one once we have checked it."), "success")
            return redirect(url_for("supplier.documents"))
        except AccountingError as e:
            get_db().rollback()
            flash(str(e), "error")
    docs = q("SELECT * FROM vendor_documents WHERE partner_id = ? ORDER BY expiry_date IS NULL, expiry_date", (pid,))
    sent = q("SELECT * FROM vendor_doc_updates WHERE partner_id = ? ORDER BY id DESC LIMIT 20", (pid,))
    return page("portal/documents.html", docs=docs, sent=sent, doc_types=portal.DOC_TYPES,
                soon=(date.today() + timedelta(days=30)).isoformat(), pre=request.args.get("type"))


@bp.route("/portal/company", methods=["GET", "POST"])
@portal_required
def company_page():
    pid = me()
    if request.method == "POST":
        fm = request.form
        try:
            vp.request_bank_change(pid, {k: fm.get(k) for k in ("bank_name", "iban", "account_name", "swift")},
                                   request.files.get("file"), portal_user_id=g.portal_user["id"])
            commit()
            flash(t("Your new bank details were sent for verification. We keep paying to the current account until "
                    "they are approved."), "success")
            return redirect(url_for("supplier.company_page"))
        except AccountingError as e:
            get_db().rollback()
            flash(str(e), "error")
    p = q("SELECT * FROM partners WHERE id = ?", (pid,), one=True)
    changes = q("SELECT * FROM bank_changes WHERE partner_id = ? ORDER BY id DESC LIMIT 10", (pid,))
    return page("portal/company.html", p=p, changes=changes, pending=vp.pending_bank_change(pid))


@bp.route("/supplier/logo")
def logo():
    from flask import send_file
    from ..branding import logo_path
    path = logo_path(company())
    if not path:
        abort(404)
    return send_file(path, mimetype="image/png", max_age=300)
