from datetime import date, timedelta

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

from .. import can_approve, check_branch, has, login_required, module_required, write_required
from ..db import commit, get_db, placeholders, q, x
from ..i18n import t
from ..ledger import AccountingError, audit
from ..money import to_int
from ..procurement import DOCS, INCOTERMS, closed_for_quotes, create_rfq, extend_closing, is_sealed, \
    issue_material_request, open_bids, po_from_mr, po_from_pr, recommend_award, requisition_from_mr, rfq_comparison, \
    rfq_from_mr, rfq_from_pr, rfq_report, save_doc, save_quote, send_rfq, transition, update_rfq
from .common import apply_search, partner_search, product_search, branch_map, default_branch, list_filters, partners_list, taxes_list, user_id
from .orders import products_list, warehouses_for
from ..projects import options as project_options, parse as parse_project

bp = Blueprint("procurement", __name__, url_prefix="/procurement")
bp.before_request(module_required("procurement"))

INFO = {
    "mr": {"title": "Material Requests", "label": "Material Request"},
    "pr": {"title": "Purchase Requisitions", "label": "Purchase Requisition"},
}


def doc_or_404(kind, doc_id):
    if kind not in DOCS:
        abort(404)
    doc = q(f"SELECT d.*, u.full_name AS requester, u.username, a.full_name AS approver, pj.code AS pj_code, "
            f"pj.name_en AS pj_en, pj.name_ar AS pj_ar FROM {DOCS[kind]['table']} d "
            f"LEFT JOIN users u ON u.id = d.requested_by LEFT JOIN users a ON a.id = d.approved_by "
            f"LEFT JOIN projects pj ON pj.id = d.project_id WHERE d.id = ?",
            (doc_id,), one=True)
    if not doc:
        abort(404)
    check_branch(doc["branch_id"])
    return doc


def doc_list(kind):
    f = list_filters()
    rows = []
    if f["branch_ids"]:
        tbl = DOCS[kind]["table"]
        sql = (f"SELECT d.*, u.full_name AS requester, u.username, pj.code AS pj_code, (SELECT COUNT(*) FROM "
               f"{DOCS[kind]['lines']} l WHERE l.{DOCS[kind]['fk']} = d.id) AS nlines FROM {tbl} d "
               f"LEFT JOIN users u ON u.id = d.requested_by LEFT JOIN projects pj ON pj.id = d.project_id "
               f"WHERE d.branch_id IN ({placeholders(f['branch_ids'])})")
        args = list(f["branch_ids"])
        if has("projects") and request.args.get("project", type=int):
            sql += " AND d.project_id = ?"
            args.append(request.args.get("project", type=int))
        if f["state"]:
            sql += " AND d.state = ?"
            args.append(f["state"])
        if f["date_from"]:
            sql += " AND d.date >= ?"
            args.append(f["date_from"])
        if f["date_to"]:
            sql += " AND d.date <= ?"
            args.append(f["date_to"])
        sql, args = apply_search(f, sql, args, [
            ("number", "Number", "d.number LIKE ?", "text"),
            ("department", "Department", "d.department LIKE ?", "text"),
            ("requester", "Requested by", "u.full_name LIKE ? OR u.username LIKE ?", "text"),
            ("project", "Project", "pj.code LIKE ? OR pj.name_en LIKE ?", "text"),
            ("product", "Product", product_search(DOCS[kind]["lines"], DOCS[kind]["fk"], "d.id"), "text")])
        if request.args.get("todo") == "approve":
            sql += " AND d.state = 'submitted'"
        rows = q(sql + " ORDER BY d.date DESC, d.id DESC LIMIT 1000", args)
    return render_template("procurement/doc_list.html", rows=rows, kind=kind, info=INFO[kind], f=f,
                           branches=branch_map(), todo=request.args.get("todo", ""))


def doc_form(kind, doc_id):
    doc = doc_or_404(kind, doc_id) if doc_id else None
    if doc and doc["state"] != "draft":
        flash(t("Only draft documents can be edited."), "error")
        return redirect(url_for(f"procurement.{kind}_view", doc_id=doc_id))
    lines = [dict(r) for r in q(f"SELECT * FROM {DOCS[kind]['lines']} WHERE {DOCS[kind]['fk']} = ? ORDER BY id",
                                (doc_id,))] if doc else []
    if request.method == "POST":
        fm = request.form
        try:
            branch_id = check_branch(fm["branch_id"])
            header = {"branch_id": branch_id, "department": fm.get("department"), "date": fm["date"],
                      "required_date": fm.get("required_date") or None,
                      "project_id": parse_project(fm.get("project_id"), branch_id, doc["project_id"] if doc else None)}
            new_lines = []
            if kind == "mr":
                wh = q("SELECT * FROM warehouses WHERE id = ?", (fm.get("warehouse_id") or 0,), one=True)
                header["warehouse_id"] = wh["id"] if wh and wh["branch_id"] == branch_id else None
                header["purpose"] = fm.get("purpose")
                for p, d, qty in zip(fm.getlist("product_id"), fm.getlist("description"), fm.getlist("quantity")):
                    if p or d:
                        new_lines.append({"product_id": int(p) if p else None, "description": d, "quantity": float(qty or 1)})
            else:
                header["justification"] = fm.get("justification")
                for p, d, qty, price, v in zip(fm.getlist("product_id"), fm.getlist("description"), fm.getlist("quantity"),
                                               fm.getlist("est_price"), fm.getlist("vendor_id")):
                    if p or d:
                        new_lines.append({"product_id": int(p) if p else None, "description": d,
                                          "quantity": float(qty or 1), "est_price": to_int(price),
                                          "vendor_id": int(v) if v else None})
            if any(ln["quantity"] <= 0 for ln in new_lines):
                raise AccountingError(t("Quantities must be greater than zero."))
            doc_id = save_doc(kind, doc_id, header, new_lines, user_id())
            if fm.get("action") == "submit":
                transition(kind, doc_id, "submit", user_id())
            commit()
            flash(t("Saved."), "success")
            return redirect(url_for(f"procurement.{kind}_view", doc_id=doc_id))
        except (AccountingError, ValueError) as e:
            get_db().rollback()
            flash(str(e), "error")
    branches = branch_map()
    return render_template("procurement/doc_form.html", doc=doc, lines=lines, kind=kind, info=INFO[kind],
                           branches=branches, warehouses=warehouses_for(list(branches)), products=products_list(),
                           vendors=partners_list("vendor"), default_branch=default_branch(),
                           projects=project_options(doc["project_id"] if doc else request.args.get("project", type=int)),
                           project_pre=request.args.get("project", type=int),
                           today=date.today().isoformat(), required=(date.today() + timedelta(days=7)).isoformat())


def doc_view(kind, doc_id):
    doc = doc_or_404(kind, doc_id)
    lines = q(f"SELECT l.*, p.code, p.name_en, p.name_ar, p.uom, p.type, "
              f"COALESCE((SELECT SUM(sq.qty) FROM stock_quants sq JOIN warehouses w ON w.id = sq.warehouse_id "
              f"WHERE sq.product_id = l.product_id AND w.branch_id = ?), 0) AS available "
              + (", v.name_en AS vname_en, v.name_ar AS vname_ar " if kind == "pr" else "") +
              f"FROM {DOCS[kind]['lines']} l LEFT JOIN products p ON p.id = l.product_id "
              + ("LEFT JOIN partners v ON v.id = l.vendor_id " if kind == "pr" else "") +
              f"WHERE l.{DOCS[kind]['fk']} = ? ORDER BY l.id", (doc["branch_id"], doc_id))
    related = {}
    if kind == "mr":
        related["prs"] = q("SELECT id, number, state FROM purchase_requisitions WHERE mr_id = ?", (doc_id,))
        related["pickings"] = q("SELECT id, number, state FROM pickings WHERE mr_id = ?", (doc_id,))
    else:
        related["mr"] = q("SELECT id, number FROM material_requests WHERE id = ?", (doc["mr_id"],), one=True) \
            if doc["mr_id"] else None
        related["rfqs"] = q("SELECT id, number, state FROM rfqs WHERE pr_id = ?", (doc_id,))
        related["pos"] = q("SELECT id, number, state FROM orders WHERE pr_id = ?", (doc_id,))
    branch = q("SELECT * FROM branches WHERE id = ?", (doc["branch_id"],), one=True)
    vendors = [v for v in partners_list("vendor") if v["vendor_status"] != "blocked"]
    return render_template("procurement/doc_view.html", doc=doc, lines=lines, kind=kind, info=INFO[kind],
                           related=related, branch=branch, vendors=vendors,
                           warehouses=[w for w in warehouses_for([doc["branch_id"]])],
                           today=date.today().isoformat(),
                           deadline=(date.today() + timedelta(days=5)).isoformat(),
                           est_total=sum(int(round(ln["quantity"] * (ln["est_price"] if kind == "pr" else 0)))
                                         for ln in lines))


def doc_action(kind, doc_id, action):
    doc = doc_or_404(kind, doc_id)
    fm = request.form
    today = date.today().isoformat()
    try:
        if action in ("submit", "approve", "reject", "draft", "cancel"):
            transition(kind, doc_id, action, user_id(), can_approve(), fm.get("reason") or fm.get("comment"),
                       bool(fm.get("override")))
        elif kind == "mr" and action == "issue":
            pk = issue_material_request(doc_id, today, user_id())
            commit()
            flash(t("Materials issued from stock."), "success")
            return redirect(url_for("inventory.picking", picking_id=pk))
        elif kind == "mr" and action == "to_rfq":
            rfq_id = rfq_from_mr(doc_id, today, user_id())
            commit()
            flash(t("Draft RFQ created. Add the details and vendors, then send it."), "success")
            return redirect(url_for("procurement.rfq_edit", rfq_id=rfq_id))
        elif kind == "mr" and action == "to_po":
            if not fm.get("vendor_id"):
                raise AccountingError(t("Choose a partner."))
            po_id = po_from_mr(doc_id, int(fm["vendor_id"]), None, today, user_id())
            commit()
            flash(t("Draft purchase order created."), "success")
            return redirect(url_for("orders.view", order_id=po_id))
        elif kind == "mr" and action == "to_pr":
            pr_id = requisition_from_mr(doc_id, today, user_id())
            commit()
            flash(t("Purchase requisition created."), "success")
            return redirect(url_for("procurement.pr_view", doc_id=pr_id))
        elif kind == "pr" and action == "rfq":
            rfq_id = rfq_from_pr(doc_id, today, fm.get("deadline") or None,
                                 [int(v) for v in fm.getlist("vendor_ids")], user_id())
            commit()
            flash(t("RFQ created."), "success")
            return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
        elif kind == "pr" and action == "po":
            if not fm.get("vendor_id"):
                raise AccountingError(t("Choose a partner."))
            po_id = po_from_pr(doc_id, int(fm["vendor_id"]), int(fm["warehouse_id"]) if fm.get("warehouse_id") else None,
                               today, user_id())
            commit()
            flash(t("Draft purchase order created."), "success")
            return redirect(url_for("orders.view", order_id=po_id))
        elif action == "delete" and doc["state"] == "draft":
            x(f"DELETE FROM {DOCS[kind]['table']} WHERE id = ?", (doc_id,))
            audit(user_id(), "delete", kind, doc_id, doc["number"])
            commit()
            flash(t("Deleted."), "success")
            return redirect(url_for(f"procurement.{kind}_list"))
        else:
            raise AccountingError(t("This action is not allowed in the current state."))
        commit()
        flash(t("Done."), "success")
    except AccountingError as e:
        get_db().rollback()
        flash(str(e), "error")
    return redirect(url_for(f"procurement.{kind}_view", doc_id=doc_id))


# routes for both documents
for _kind in ("mr", "pr"):
    def _make(kind):
        bp.add_url_rule(f"/{kind}", f"{kind}_list", login_required(lambda: doc_list(kind)))
        bp.add_url_rule(f"/{kind}/new", f"{kind}_new", write_required(lambda: doc_form(kind, None)), methods=["GET", "POST"])
        bp.add_url_rule(f"/{kind}/<int:doc_id>/edit", f"{kind}_edit",
                        write_required(lambda doc_id: doc_form(kind, doc_id)), methods=["GET", "POST"])
        bp.add_url_rule(f"/{kind}/<int:doc_id>", f"{kind}_view", login_required(lambda doc_id: doc_view(kind, doc_id)))
        bp.add_url_rule(f"/{kind}/<int:doc_id>/<action>", f"{kind}_action",
                        write_required(lambda doc_id, action: doc_action(kind, doc_id, action)), methods=["POST"])
    _make(_kind)


# ---------------------------------------------------------------- RFQ

def get_rfq(rfq_id):
    r = q("SELECT r.*, pr.number AS pr_number, mr.number AS mr_number, p.name_en AS aw_en, p.name_ar AS aw_ar, "
          "pj.code AS pj_code, pj.name_en AS pj_en, pj.name_ar AS pj_ar, ou.full_name AS opened_name FROM rfqs r "
          "LEFT JOIN purchase_requisitions pr ON pr.id = r.pr_id LEFT JOIN material_requests mr ON mr.id = r.mr_id "
          "LEFT JOIN partners p ON p.id = r.awarded_vendor_id LEFT JOIN projects pj ON pj.id = r.project_id "
          "LEFT JOIN users ou ON ou.id = r.opened_by WHERE r.id = ?", (rfq_id,), one=True)
    if not r:
        abort(404)
    check_branch(r["branch_id"])
    return r


def invitable_vendors():
    return [v for v in partners_list("vendor") if v["vendor_status"] != "blocked"]


@bp.route("/rfq")
@login_required
def rfq_list():
    f = list_filters()
    rows = []
    if f["branch_ids"]:
        sql = (f"SELECT r.*, pr.number AS pr_number, p.name_en AS aw_en, p.name_ar AS aw_ar, "
               f"(SELECT COUNT(*) FROM rfq_vendors WHERE rfq_id = r.id) AS nvendors, "
               f"(SELECT COUNT(*) FROM rfq_vendors WHERE rfq_id = r.id AND state IN ('quoted', 'awarded')) AS nquotes "
               f"FROM rfqs r LEFT JOIN purchase_requisitions pr ON pr.id = r.pr_id "
               f"LEFT JOIN partners p ON p.id = r.awarded_vendor_id WHERE r.branch_id IN ({placeholders(f['branch_ids'])})")
        args = list(f["branch_ids"])
        if f["state"]:
            sql += " AND r.state = ?"
            args.append(f["state"])
        sql, args = apply_search(f, sql, args, [
            ("number", "Number", "r.number LIKE ?", "text"),
            ("requisition", "Purchase requisition", "pr.number LIKE ?", "text"),
            ("vendor", "Vendor", "EXISTS (SELECT 1 FROM rfq_vendors sv JOIN partners sp ON sp.id = sv.partner_id "
                                 f"WHERE sv.rfq_id = r.id AND ({partner_search('sp')}))", "text")])
        rows = q(sql + " ORDER BY r.date DESC, r.id DESC LIMIT 1000", args)
    return render_template("procurement/rfq_list.html", rows=rows, f=f, branches=branch_map())


def parse_rfq_form(fm):
    closing = (fm.get("closing_date") or "").strip()
    header = {"closing_at": f"{closing}T{(fm.get('closing_time') or '17:00')[:5]}" if closing else None,
              "validity_days": int(fm["validity_days"]) if (fm.get("validity_days") or "").isdigit() else None,
              "payment_terms": fm.get("payment_terms") or None,
              "incoterms": fm.get("incoterms") if fm.get("incoterms") in INCOTERMS else None,
              "delivery_place": fm.get("delivery_place") or None, "sealed": 1 if fm.get("sealed") else 0,
              "terms": fm.get("terms") or None}
    lines = []
    cols = ("product_id", "item_code", "description", "specification", "manufacturer", "part_number", "uom",
            "quantity", "required_date", "allow_alternative", "pr_line_id", "mr_line_id")
    for row in zip(*[fm.getlist(c) for c in cols]):
        ln = dict(zip(cols, row))
        if not (ln["product_id"] or ln["description"]):
            continue
        ln["product_id"] = int(ln["product_id"]) if ln["product_id"] else None
        ln["quantity"] = float(ln["quantity"] or 1)
        ln["allow_alternative"] = ln["allow_alternative"] == "1"
        for k in ("pr_line_id", "mr_line_id"):
            ln[k] = int(ln[k]) if ln[k] else None
        for k in ("item_code", "specification", "manufacturer", "part_number", "uom", "required_date"):
            ln[k] = (ln[k] or "").strip() or None
        lines.append(ln)
    return header, lines, [int(v) for v in fm.getlist("vendor_ids")]


@bp.route("/rfq/new", methods=["GET", "POST"])
@bp.route("/rfq/<int:rfq_id>/edit", methods=["GET", "POST"])
@write_required
def rfq_edit(rfq_id=None):
    from ..workflow import default_terms
    r = get_rfq(rfq_id) if rfq_id else None
    if r and r["state"] != "draft":
        flash(t("Only draft documents can be edited."), "error")
        return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
    lines = [dict(x) for x in q("SELECT * FROM rfq_lines WHERE rfq_id = ? ORDER BY id", (rfq_id,))] if r else []
    selected = [v[0] for v in q("SELECT partner_id FROM rfq_vendors WHERE rfq_id = ?", (rfq_id,))] if r else []
    if request.method == "POST":
        fm = request.form
        try:
            header, lines, vendor_ids = parse_rfq_form(fm)
            if r:
                update_rfq(rfq_id, header, lines, vendor_ids, fm.get("notes"),
                           parse_project(fm.get("project_id"), r["branch_id"], r["project_id"]), user_id())
            else:
                branch_id = check_branch(fm["branch_id"])
                rfq_id = create_rfq(branch_id, fm["date"], None, lines, vendor_ids, notes=fm.get("notes"),
                                    user_id=user_id(), project_id=parse_project(fm.get("project_id"), branch_id),
                                    header=header)
            if fm.get("action") in ("send", "email"):
                sent, skipped = send_rfq(rfq_id, user_id(), email=fm["action"] == "email")
                if fm["action"] == "email":
                    flash(f"{t('RFQ emailed to')} {sent} {t('vendors')}."
                          + (f" {t('No email address')}: {', '.join(skipped)}" if skipped else ""), "success")
            commit()
            flash(t("Saved."), "success")
            return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
        except (AccountingError, ValueError) as e:
            get_db().rollback()
            flash(str(e), "error")
            header, lines, selected = parse_rfq_form(fm)
            r = dict(r or {}, **header, notes=fm.get("notes"), branch_id=fm.get("branch_id") or (r and r["branch_id"]),
                     date=fm.get("date") or (r and r["date"]), project_id=fm.get("project_id"))
    closing = dict(r).get("closing_at") if r else None
    return render_template("procurement/rfq_form.html", r=r, lines=lines, selected=selected, branches=branch_map(),
                           products=products_list(), projects=project_options(r["project_id"] if r else None),
                           vendors=invitable_vendors(), default_branch=default_branch(), today=date.today().isoformat(),
                           closing=closing or f"{(date.today() + timedelta(days=7)).isoformat()}T17:00",
                           incoterms=INCOTERMS, default_terms=default_terms("rfq"))


@bp.route("/rfq/<int:rfq_id>")
@login_required
def rfq_view(rfq_id):
    r = get_rfq(rfq_id)
    branch = q("SELECT * FROM branches WHERE id = ?", (r["branch_id"],), one=True)
    pos = q("SELECT id, number, state FROM orders WHERE rfq_id = ?", (rfq_id,))
    invited = {v["partner_id"] for v in q("SELECT partner_id FROM rfq_vendors WHERE rfq_id = ?", (rfq_id,))}
    lines = q("SELECT * FROM rfq_lines WHERE rfq_id = ? ORDER BY id", (rfq_id,))
    return render_template("procurement/rfq_view.html", r=r, c=rfq_comparison(rfq_id), branch=branch, pos=pos,
                           lines=lines, sealed=is_sealed(r), closed=closed_for_quotes(r),
                           warehouses=warehouses_for([r["branch_id"]]),
                           other_vendors=[v for v in invitable_vendors() if v["id"] not in invited])


@bp.route("/rfq/<int:rfq_id>/quote/<int:rv_id>", methods=["GET", "POST"])
@write_required
def rfq_quote(rfq_id, rv_id):
    r = get_rfq(rfq_id)
    rv = q("SELECT rv.*, p.name_en, p.name_ar FROM rfq_vendors rv JOIN partners p ON p.id = rv.partner_id "
           "WHERE rv.id = ? AND rv.rfq_id = ?", (rv_id, rfq_id), one=True)
    if not rv:
        abort(404)
    lines = q("SELECT rl.*, p.code, p.name_en, p.name_ar, p.purchase_tax_id FROM rfq_lines rl "
              "LEFT JOIN products p ON p.id = rl.product_id WHERE rl.rfq_id = ? ORDER BY rl.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']}", "").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"
            save_quote(rv_id, prices, taxes, fm.get("quote_ref"), fm.get("quote_date") or None,
                       int(fm["lead_days"]) if fm.get("lead_days") else None, fm.get("notes"),
                       declined=fm.get("action") == "decline", user_id=user_id(), offered=offered, alternatives=alts,
                       valid_until=fm.get("valid_until") or None, payment_terms=fm.get("payment_terms") or None)
            commit()
            flash(t("Saved."), "success")
            return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
        except (AccountingError, ValueError) as e:
            get_db().rollback()
            flash(str(e), "error")
    sealed = is_sealed(r)
    existing = {} if sealed else {r2["rfq_line_id"]: r2 for r2 in q("SELECT * FROM rfq_quotes WHERE rfq_vendor_id = ?",
                                                                   (rv_id,))}
    return render_template("procurement/rfq_quote.html", r=r, rv=rv, lines=lines, existing=existing, sealed=sealed,
                           closed=closed_for_quotes(r), taxes=taxes_list("purchase"), today=date.today().isoformat())


@bp.route("/rfq/<int:rfq_id>/<action>", methods=["POST"])
@write_required
def rfq_action(rfq_id, action):
    r = get_rfq(rfq_id)
    fm = request.form
    try:
        if action in ("award", "recommend"):
            po_id = recommend_award(rfq_id, int(fm["rfq_vendor_id"]),
                                    int(fm["warehouse_id"]) if fm.get("warehouse_id") else None,
                                    fm.get("reason"), user_id())
            commit()
            if po_id:
                flash(t("Vendor awarded. The purchase order is confirmed; send it to the vendor."), "success")
                return redirect(url_for("orders.view", order_id=po_id))
            flash(t("The award is waiting for approval."), "success")
            return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
        elif action in ("approve", "reject"):
            from ..workflow import act_on_doc
            act_on_doc("rfq_award", rfq_id, user_id(), action, fm.get("reason") or fm.get("comment"),
                       bool(fm.get("override")))
            commit()
            po = q("SELECT id FROM orders WHERE rfq_id = ? ORDER BY id DESC LIMIT 1", (rfq_id,), one=True)
            if action == "approve" and po and q("SELECT state FROM rfqs WHERE id = ?", (rfq_id,), one=True)[0] == "awarded":
                flash(t("Award approved. The purchase order is confirmed; send it to the vendor."), "success")
                return redirect(url_for("orders.view", order_id=po["id"]))
            flash(t("Done."), "success")
            return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
        elif action == "add_vendor" and r["state"] in ("draft", "sent"):
            if closed_for_quotes(r):
                raise AccountingError(t("The RFQ is closed; quotations are no longer accepted. Extend the closing time first."))
            for v in fm.getlist("vendor_ids"):
                x("INSERT OR IGNORE INTO rfq_vendors (rfq_id, partner_id) VALUES (?,?)", (rfq_id, int(v)))
        elif action in ("sent", "email"):
            sent, skipped = send_rfq(rfq_id, user_id(), email=action == "email")
            if action == "email":
                commit()
                flash(f"{t('RFQ emailed to')} {sent} {t('vendors')}."
                      + (f" {t('No email address')}: {', '.join(skipped)}" if skipped else ""), "success")
                return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))
        elif action == "open":
            open_bids(rfq_id, user_id())
        elif action == "extend":
            extend_closing(rfq_id, f"{fm.get('closing_date')}T{(fm.get('closing_time') or '17:00')[:5]}"
                           if fm.get("closing_date") else None, user_id())
        elif action == "cancel" and r["state"] in ("draft", "sent", "award_pending"):
            from ..workflow import cancel as cancel_approval
            cancel_approval("rfq_award", rfq_id, user_id(), t("Cancelled"))
            x("UPDATE rfqs SET state = 'cancelled' WHERE id = ?", (rfq_id,))
        else:
            raise AccountingError(t("This action is not allowed in the current state."))
        audit(user_id(), action, "rfq", rfq_id, r["number"])
        commit()
        flash(t("Done."), "success")
    except (AccountingError, ValueError) as e:
        get_db().rollback()
        flash(str(e), "error")
    return redirect(url_for("procurement.rfq_view", rfq_id=rfq_id))


@bp.route("/rfq/<int:rfq_id>/print/<int:rv_id>")
@login_required
def rfq_print(rfq_id, rv_id):
    from flask import Response
    from ..exports import to_pdf
    r = get_rfq(rfq_id)
    if not q("SELECT 1 FROM rfq_vendors WHERE id = ? AND rfq_id = ?", (rv_id, rfq_id), one=True):
        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"})
