from datetime import date

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

from .. import check_branch, login_required, write_required
from ..db import commit, placeholders, q, x
from ..i18n import t
from ..ledger import INVOICE_KINDS, AccountingError, audit, create_payment, invoice_residuals, set_move_state
from ..money import to_int
from .common import apply_search, partner_search, product_search, branch_map, default_branch, journals_for, list_filters, partners_list, user_id

bp = Blueprint("payments", __name__, url_prefix="/payments")


@bp.route("/")
@login_required
def index():
    f = list_filters()
    ptype = request.args.get("partner_type", "")
    rows = []
    if f["branch_ids"]:
        sql = (f"SELECT p.*, pa.name_en AS pname_en, pa.name_ar AS pname_ar, j.code AS jcode, i.number AS inv_number "
               f"FROM payments p JOIN partners pa ON pa.id = p.partner_id JOIN journals j ON j.id = p.journal_id "
               f"LEFT JOIN invoices i ON i.id = p.invoice_id "
               f"WHERE p.branch_id IN ({placeholders(f['branch_ids'])})")
        args = list(f["branch_ids"])
        if ptype in ("customer", "vendor"):
            sql += " AND p.partner_type = ?"
            args.append(ptype)
        if f["date_from"]:
            sql += " AND p.date >= ?"
            args.append(f["date_from"])
        if f["date_to"]:
            sql += " AND p.date <= ?"
            args.append(f["date_to"])
        if f["state"] in ("posted", "cancelled"):
            sql += " AND p.state = ?"
            args.append(f["state"])
        sql, args = apply_search(f, sql, args, [
            ("number", "Number", "p.name LIKE ?", "text"),
            ("partner", "Partner", partner_search("pa"), "text"),
            ("ref", "Reference", "p.ref LIKE ?", "text"),
            ("invoice", "Invoice / bill", "i.number LIKE ? OR i.ref LIKE ?", "text"),
            ("amount", "Amount", "p.amount = ?", "amount")])
        rows = q(sql + " ORDER BY p.date DESC, p.id DESC LIMIT 1000", args)
    return render_template("payments/list.html", rows=rows, f=f, branches=branch_map(), ptype=ptype)


@bp.route("/new", methods=["GET", "POST"])
@write_required
def form():
    inv = None
    inv_id = request.values.get("invoice_id", type=int)
    if inv_id:
        inv = q("SELECT * FROM invoices WHERE id = ? AND state = 'posted'", (inv_id,), one=True)
        if not inv:
            abort(404)
        check_branch(inv["branch_id"])
    if request.method == "POST":
        fm = request.form
        try:
            data = {
                "branch_id": check_branch(fm["branch_id"]),
                "journal_id": int(fm["journal_id"]),
                "partner_id": int(fm["partner_id"]) if fm.get("partner_id") else None,
                "partner_type": fm["partner_type"],
                "payment_type": fm["payment_type"],
                "date": fm["date"],
                "amount": to_int(fm["amount"]),
                "ref": fm.get("ref"),
                "invoice_id": inv_id,
                "currency": fm.get("currency") or None,
                "rate": float(fm.get("rate") or 0),
            }
            if not data["partner_id"]:
                raise AccountingError(t("Choose a partner."))
            if data["partner_type"] not in ("customer", "vendor") or data["payment_type"] not in ("inbound", "outbound"):
                abort(400)
            pid = create_payment(data, user_id())
            commit()
            flash(t("Payment registered."), "success")
            if inv_id:
                return redirect(url_for("invoices.view", inv_id=inv_id))
            return redirect(url_for("payments.view", pid=pid))
        except (AccountingError, ValueError) as e:
            from ..db import get_db
            get_db().rollback()
            flash(str(e), "error")
    defaults = {"partner_type": request.args.get("partner_type", "customer"), "date": date.today().isoformat(),
                "branch_id": default_branch()}
    defaults["payment_type"] = "inbound" if defaults["partner_type"] == "customer" else "outbound"
    if inv:
        info = INVOICE_KINDS[inv["kind"]]
        customer = info["partner_type"] == "customer"
        inbound = customer == (info["sign"] > 0)
        defaults.update(partner_type=info["partner_type"], payment_type="inbound" if inbound else "outbound",
                        branch_id=inv["branch_id"], partner_id=inv["partner_id"], ref=inv["number"],
                        amount=invoice_residuals([inv["id"]])[inv["id"]])
        if inv["currency"]:
            from ..ledger import cross_rate
            bcur = q("SELECT currency FROM branches WHERE id = ?", (inv["branch_id"],), one=True)["currency"]
            try:
                defaults["rate"] = cross_rate(inv["currency"], bcur, defaults["date"])
            except AccountingError:
                defaults["rate"] = inv["rate"]
    if request.method == "POST":
        defaults.update(request.form.items())
        try:
            defaults["amount"] = to_int(request.form.get("amount") or 0)
        except ValueError:
            defaults["amount"] = 0
    branches = branch_map()
    return render_template("payments/form.html", d=defaults, inv=inv, branches=branches,
                           journals=journals_for(list(branches), ["bank", "cash"]), partners=partners_list(),
                           currencies=q("SELECT code FROM currencies WHERE active = 1 ORDER BY code"))


@bp.route("/<int:pid>")
@login_required
def view(pid):
    p = q("SELECT p.*, pa.name_en AS pname_en, pa.name_ar AS pname_ar, j.code AS jcode, j.name_en AS jname_en, "
          "j.name_ar AS jname_ar, i.number AS inv_number FROM payments p JOIN partners pa ON pa.id = p.partner_id "
          "JOIN journals j ON j.id = p.journal_id LEFT JOIN invoices i ON i.id = p.invoice_id WHERE p.id = ?",
          (pid,), one=True)
    if not p:
        abort(404)
    check_branch(p["branch_id"])
    branch = branch_map().get(p["branch_id"])
    if request.args.get("export"):
        from .. import currency_decimals
        from ..exports import Report, respond
        from ..i18n import nm
        inbound = p["payment_type"] == "inbound"
        cur = p["currency"] or branch["currency"]
        rep = Report("Receipt Voucher" if inbound else "Payment Voucher", decimals=currency_decimals(cur), signatures=True)
        rep.details = [("Number", p["name"]), ("Date", p["date"]),
                       ("Received from" if inbound else "Paid to", nm({"name_en": p["pname_en"], "name_ar": p["pname_ar"]})),
                       ("Journal", f"{p['jcode']} — {nm({'name_en': p['jname_en'], 'name_ar': p['jname_ar']})}"),
                       ("Branch", f"{branch['code']} — {nm(branch)}"), ("Reference", p["ref"] or "—")]
        if p["inv_number"]:
            rep.details.append(("Document", p["inv_number"]))
        if p["currency"]:
            rep.details.append(("Exchange rate", f"1 {p['currency']} = {p['rate']} {branch['currency']}"))
        rep.column(t("Account"), width=2.6).column(t("Label"), width=2.4).column(t("Debit"), "num").column(t("Credit"), "num")
        lines = q("SELECT ml.*, a.code, a.name_en, a.name_ar FROM move_lines ml JOIN accounts a ON a.id = ml.account_id "
                  "WHERE ml.move_id = ? ORDER BY ml.id", (p["move_id"],))
        rep.decimals = currency_decimals(branch["currency"])
        for ln in lines:
            rep.row([f"{ln['code']}  {nm(ln)}", ln["label"] or "", ln["debit"] or None, ln["credit"] or None])
        rep.totals = [(f"{t('Amount')} ({cur})", p["amount"], True)]
        if p["state"] != "posted":
            rep.notes.append(t("This payment is cancelled."))
        out = respond(rep, (p["name"] or "Payment").replace("/", "-"))
        if out:
            return out
    return render_template("payments/view.html", p=p, branch=branch)


@bp.route("/<int:pid>/cancel", methods=["POST"])
@write_required
def cancel(pid):
    p = q("SELECT * FROM payments WHERE id = ?", (pid,), one=True)
    if not p:
        abort(404)
    check_branch(p["branch_id"])
    try:
        if p["state"] != "posted":
            raise AccountingError(t("This action is not allowed in the current state."))
        set_move_state(p["move_id"], "cancelled", user_id())
        x("UPDATE payments SET state = 'cancelled' WHERE id = ?", (pid,))
        audit(user_id(), "cancel", "payment", pid, p["name"])
        commit()
        flash(t("Done."), "success")
    except AccountingError as e:
        flash(str(e), "error")
    return redirect(url_for("payments.view", pid=pid))
