"""Helpers shared by the document views."""
from flask import g, request

from .. import allowed_branches, context_branch_ids
from ..db import placeholders, q
from ..i18n import nm


def journals_for(branch_ids, types=None):
    if not branch_ids:
        return []
    sql = f"SELECT * FROM journals WHERE active = 1 AND branch_id IN ({placeholders(branch_ids)})"
    args = list(branch_ids)
    if types:
        sql += f" AND type IN ({placeholders(types)})"
        args += list(types)
    return q(sql + " ORDER BY branch_id, code", args)


def accounts_list():
    return q("SELECT * FROM accounts WHERE active = 1 AND is_group = 0 ORDER BY code")


def partners_list(kind=None):
    sql = "SELECT * FROM partners WHERE active = 1"
    if kind in ("customer", "vendor"):
        sql += f" AND is_{kind} = 1"
    return q(sql + " ORDER BY name_en")


def taxes_list(scope=None):
    sql = "SELECT * FROM taxes WHERE active = 1"
    args = []
    if scope:
        sql += " AND scope = ?"
        args.append(scope)
    return q(sql + " ORDER BY rate DESC", args)


def default_branch():
    ids = context_branch_ids()
    return ids[0] if ids else None


def list_filters():
    """Common filters for document lists: branch context, date range, state, search facets."""
    ids = context_branch_ids()
    return {
        "branch_ids": ids,
        "date_from": request.args.get("date_from", ""),
        "date_to": request.args.get("date_to", ""),
        "state": request.args.get("state", ""),
        "search": request.args.get("q", "").strip(),
        "facets": search_facets(),
        "fields": [],
    }


def search_facets():
    """Odoo-style search chips from the URL: ?s=<field>:<text> (repeatable); ?q=<text> searches every field."""
    out = []
    for v in request.args.getlist("s"):
        key, _, val = v.partition(":")
        val = val.strip()
        if val:
            out.append((key.strip(), val))
    if request.args.get("q", "").strip():
        out.append(("", request.args["q"].strip()))
    return out


def apply_search(f, sql, args, fields):
    """Add the search chips to a list query.

    fields: [(key, label, sql, kind)] -- sql uses one or more "?" for the typed text; kind "text" matches part of the
    text (LIKE), "amount" matches an exact amount. Several chips on one field = any of them (OR); chips on different
    fields must all match (AND); a chip without a field searches every text field (and the amount when it is a number)."""
    from ..money import to_int
    f["fields"] = [(k, lbl) for k, lbl, _sql, _kind in fields]
    labels = dict(f["fields"])
    f["chips"] = [(k, labels.get(k, ""), v) for k, v in f["facets"] if k == "" or k in labels]
    groups = {}
    for k, v in f["facets"]:
        if k == "" or k in labels:
            groups.setdefault(k, []).append(v)
    for k, vals in groups.items():
        ors = []
        for v in vals:
            for key, _lbl, expr, kind in fields:
                if k and key != k:
                    continue
                if kind == "amount":
                    try:
                        num = to_int(v.replace(",", ""))
                    except (ValueError, TypeError):
                        continue
                    ors.append(f"({expr})")
                    args += [num] * expr.count("?")
                else:
                    ors.append(f"({expr})")
                    args += [f"%{v}%"] * expr.count("?")
        sql += " AND (" + (" OR ".join(ors) or "0") + ")"
    return sql, args


def partner_search(alias):
    return (f"{alias}.name_en LIKE ? OR {alias}.name_ar LIKE ? OR {alias}.vat_no LIKE ? OR {alias}.phone LIKE ? "
            f"OR {alias}.email LIKE ?")


def product_search(lines, fk, owner):
    return (f"EXISTS (SELECT 1 FROM {lines} sl LEFT JOIN products sp ON sp.id = sl.product_id WHERE sl.{fk} = {owner} "
            f"AND (sp.name_en LIKE ? OR sp.name_ar LIKE ? OR sp.code LIKE ? OR sp.barcode LIKE ?"
            + (" OR sl.description LIKE ?" if lines != "picking_lines" else "") + "))")


def branch_map():
    return {b["id"]: b for b in allowed_branches()}


def label(row):
    return nm(row) if row else ""


def user_id():
    return g.user["id"] if g.get("user") else None
