from datetime import date

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

from .. import allowed_branch_ids, check_branch, context_branch_ids, currency_decimals, has, login_required, \
    module_required, write_required
from ..db import commit, get_db, placeholders, q, x
from ..i18n import nm, t
from ..ledger import AccountingError, audit, effective_tax
from ..money import plain, to_int
from ..pos import close_session, create_order, open_session, refund_order, session_summary
from .common import branch_map, partners_list, user_id

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


def registers_for(ids):
    if not ids:
        return []
    return q(f"SELECT r.*, (SELECT id FROM pos_sessions s WHERE s.register_id = r.id AND s.state = 'open') AS open_session, "
             f"(SELECT u.full_name FROM pos_sessions s JOIN users u ON u.id = s.user_id WHERE s.register_id = r.id "
             f"AND s.state = 'open') AS cashier FROM pos_registers r WHERE r.active = 1 AND r.branch_id IN "
             f"({placeholders(ids)}) ORDER BY r.branch_id, r.name", list(ids))


def session_or_404(sid):
    s = q("SELECT s.*, r.name AS register_name, r.warehouse_id, r.partner_id AS default_partner, u.full_name AS cashier "
          "FROM pos_sessions s JOIN pos_registers r ON r.id = s.register_id LEFT JOIN users u ON u.id = s.user_id "
          "WHERE s.id = ?", (sid,), one=True)
    if not s:
        abort(404)
    check_branch(s["branch_id"])
    return s


@bp.route("/")
@login_required
def index():
    ids = context_branch_ids()
    sessions = q(f"SELECT s.*, r.name AS register_name, u.full_name AS cashier, "
                 f"(SELECT COUNT(*) FROM pos_orders WHERE session_id = s.id) AS n, "
                 f"(SELECT COALESCE(SUM(amount_total), 0) FROM pos_orders WHERE session_id = s.id) AS total "
                 f"FROM pos_sessions s JOIN pos_registers r ON r.id = s.register_id LEFT JOIN users u ON u.id = s.user_id "
                 f"WHERE s.branch_id IN ({placeholders(ids)}) ORDER BY s.id DESC LIMIT 100", ids) if ids else []
    return render_template("pos/index.html", registers=registers_for(ids), sessions=sessions, branches=branch_map())


@bp.route("/register/new", methods=["GET", "POST"])
@bp.route("/register/<int:rid>", methods=["GET", "POST"])
@write_required
def register_form(rid=None):
    r = q("SELECT * FROM pos_registers WHERE id = ?", (rid,), one=True) if rid else None
    if r:
        check_branch(r["branch_id"])
    branches = branch_map()
    if request.method == "POST":
        f = request.form
        try:
            branch_id = check_branch(f["branch_id"])
            partner = f.get("partner_id")
            if not partner:
                walk_in = q("SELECT id FROM partners WHERE name_en = 'Walk-in Customer'", one=True)
                partner = walk_in["id"] if walk_in else x(
                    "INSERT INTO partners (name_en, name_ar, is_customer) VALUES ('Walk-in Customer', 'عميل نقدي', 1)")
            vals = (f["name"].strip(), branch_id, int(f["warehouse_id"]) if f.get("warehouse_id") else None,
                    int(f["cash_journal_id"]), int(f["card_journal_id"]) if f.get("card_journal_id") else None,
                    int(partner), 1 if f.get("active") else 0)
            for jid in (vals[3], vals[4]):
                if jid:
                    j = q("SELECT * FROM journals WHERE id = ?", (jid,), one=True)
                    if j["branch_id"] != branch_id or j["type"] not in ("cash", "bank"):
                        raise AccountingError(t("Payments need a bank or cash journal with an account."))
            if rid:
                x("UPDATE pos_registers SET name=?, branch_id=?, warehouse_id=?, cash_journal_id=?, card_journal_id=?, "
                  "partner_id=?, active=? WHERE id=?", vals + (rid,))
            else:
                rid = x("INSERT INTO pos_registers (name, branch_id, warehouse_id, cash_journal_id, card_journal_id, "
                        "partner_id, active) VALUES (?,?,?,?,?,?,?)", vals)
            audit(user_id(), "save", "pos_register", rid)
            commit()
            flash(t("Saved."), "success")
            return redirect(url_for("pos.index"))
        except (AccountingError, ValueError, KeyError) as e:
            get_db().rollback()
            flash(str(e), "error")
    ids = list(branches)
    return render_template("pos/register.html", r=r, branches=branches,
                           warehouses=q(f"SELECT * FROM warehouses WHERE branch_id IN ({placeholders(ids)})", ids) if ids else [],
                           journals=q(f"SELECT * FROM journals WHERE type IN ('cash', 'bank') AND branch_id IN "
                                      f"({placeholders(ids)}) ORDER BY branch_id, code", ids) if ids else [],
                           customers=partners_list("customer"))


@bp.route("/register/<int:rid>/open", methods=["POST"])
@write_required
def open_register(rid):
    r = q("SELECT * FROM pos_registers WHERE id = ?", (rid,), one=True)
    if not r:
        abort(404)
    check_branch(r["branch_id"])
    existing = q("SELECT id FROM pos_sessions WHERE register_id = ? AND state = 'open'", (rid,), one=True)
    if existing:
        return redirect(url_for("pos.sell", sid=existing["id"]))
    try:
        sid = open_session(rid, to_int(request.form.get("opening_cash") or 0), user_id())
        commit()
        return redirect(url_for("pos.sell", sid=sid))
    except (AccountingError, ValueError) as e:
        get_db().rollback()
        flash(str(e), "error")
        return redirect(url_for("pos.index"))


@bp.route("/session/<int:sid>")
@login_required
def sell(sid):
    s = session_or_404(sid)
    if s["state"] != "open":
        return redirect(url_for("pos.session", sid=sid))
    branch = q("SELECT * FROM branches WHERE id = ?", (s["branch_id"],), one=True)
    dec = currency_decimals(branch["currency"])
    taxes = {r["id"]: r["rate"] for r in q("SELECT id, rate FROM taxes")}
    stock = None
    if s["warehouse_id"] and has("inventory"):
        stock = {r["product_id"]: r["qty"] for r in q("SELECT product_id, qty FROM stock_quants WHERE warehouse_id = ?",
                                                      (s["warehouse_id"],))}
        for r in q("SELECT l.product_id, SUM(l.quantity) AS qty FROM pos_order_lines l JOIN pos_orders o "
                   "ON o.id = l.order_id WHERE o.session_id = ? GROUP BY l.product_id", (sid,)):
            stock[r["product_id"]] = stock.get(r["product_id"], 0) - r["qty"]
    products = [{"id": p["id"], "code": p["code"] or "", "barcode": p["barcode"] or "", "name": nm(p),
                 "category": p["category"] or "", "price": p["sale_price"] / 1000.0,
                 "tax": taxes.get(effective_tax(s["branch_id"], p["sale_tax_id"], "sale"), 0),
                 "stock": stock.get(p["id"], 0) if p["type"] == "stock" and stock is not None else None}
                for p in q("SELECT * FROM products WHERE active = 1 AND type != 'consumable' AND sale_price > 0 "
                           "ORDER BY category, name_en")]
    return render_template("pos/sell.html", s=s, branch=branch, products=products, decimals=dec,
                           categories=sorted({p["category"] for p in products if p["category"]}),
                           customers=partners_list("customer"), summary=session_summary(sid))


@bp.route("/session/<int:sid>/order", methods=["POST"])
@write_required
def order(sid):
    s = session_or_404(sid)
    data = request.get_json(silent=True) or {}
    try:
        oid = create_order(sid, data.get("items") or [], to_int(data.get("cash") or 0) if data.get("cash") not in (None, "")
                           else None, to_int(data.get("card") or 0), int(data["partner_id"]) if data.get("partner_id") else None,
                           user_id())
        commit()
        o = q("SELECT * FROM pos_orders WHERE id = ?", (oid,), one=True)
        return jsonify(ok=True, id=oid, number=o["number"], total=plain(o["amount_total"]), change=plain(o["change_given"]) or "0",
                       receipt=url_for("pos.receipt", oid=oid))
    except (AccountingError, ValueError, KeyError) as e:
        get_db().rollback()
        return jsonify(ok=False, error=str(e)), 400


@bp.route("/session/<int:sid>/orders")
@login_required
def orders(sid):
    s = session_or_404(sid)
    rows = q("SELECT o.*, p.name_en AS pname_en, p.name_ar AS pname_ar, "
             "(SELECT id FROM pos_orders r WHERE r.refund_of = o.id) AS refunded_by FROM pos_orders o "
             "LEFT JOIN partners p ON p.id = o.partner_id WHERE o.session_id = ? ORDER BY o.id DESC", (sid,))
    branch = q("SELECT * FROM branches WHERE id = ?", (s["branch_id"],), one=True)
    return render_template("pos/orders.html", s=s, rows=rows, branch=branch)


@bp.route("/order/<int:oid>/refund", methods=["POST"])
@write_required
def refund(oid):
    o = q("SELECT * FROM pos_orders WHERE id = ?", (oid,), one=True)
    if not o:
        abort(404)
    session_or_404(o["session_id"])
    try:
        rid = refund_order(oid, user_id())
        commit()
        flash(t("Refund recorded. Pay the customer back in cash."), "success")
        return redirect(url_for("pos.receipt", oid=rid))
    except AccountingError as e:
        get_db().rollback()
        flash(str(e), "error")
        return redirect(url_for("pos.orders", sid=o["session_id"]))


@bp.route("/order/<int:oid>/receipt")
@login_required
def receipt(oid):
    o = q("SELECT o.*, p.name_en AS pname_en, p.name_ar AS pname_ar, p.vat_no AS pvat, u.full_name AS cashier, "
          "r.number AS refund_number FROM pos_orders o LEFT JOIN partners p ON p.id = o.partner_id "
          "LEFT JOIN users u ON u.id = o.user_id LEFT JOIN pos_orders r ON r.id = o.refund_of WHERE o.id = ?",
          (oid,), one=True)
    if not o:
        abort(404)
    s = session_or_404(o["session_id"])
    lines = q("SELECT l.*, p.name_en, p.name_ar, tx.rate FROM pos_order_lines l JOIN products p ON p.id = l.product_id "
              "LEFT JOIN taxes tx ON tx.id = l.tax_id WHERE l.order_id = ? ORDER BY l.id", (oid,))
    branch = q("SELECT * FROM branches WHERE id = ?", (s["branch_id"],), one=True)
    return render_template("pos/receipt.html", o=o, s=s, lines=lines, branch=branch,
                           auto=request.args.get("print") == "1")


@bp.route("/session/<int:sid>/close", methods=["GET", "POST"])
@login_required
def session(sid):
    s = session_or_404(sid)
    if request.method == "POST":
        if g.user["role"] not in ("admin", "accountant"):
            abort(403)
        try:
            counted = request.form.get("counted_cash", "").strip()
            close_session(sid, to_int(counted) if counted != "" else None, user_id())
            commit()
            flash(t("Session closed and posted."), "success")
        except (AccountingError, ValueError) as e:
            get_db().rollback()
            flash(str(e), "error")
        return redirect(url_for("pos.session", sid=sid))
    branch = q("SELECT * FROM branches WHERE id = ?", (s["branch_id"],), one=True)
    products = q("SELECT p.code, p.name_en, p.name_ar, SUM(l.quantity) AS qty, SUM(l.subtotal) AS amount FROM pos_order_lines l "
                 "JOIN pos_orders o ON o.id = l.order_id JOIN products p ON p.id = l.product_id WHERE o.session_id = ? "
                 "GROUP BY p.id ORDER BY amount DESC", (sid,))
    return render_template("pos/session.html", s=s, summ=session_summary(sid), branch=branch, products=products)
