from PDAPI import *
import TempLateAPI.GERP.API.FormAPI.FormData as FormData


__metadata__ = {
    "route": "{DEFAULT_ROUTE}/<TableName>",
    "methods": ["GET"],
    "blueprint": "GERP",
    "permission": 1.0,
    "attributes": [],
    "limit": "1 per second"
}


def HandleRequest(_CleanedData):
    Table = FormData.GetTable(_CleanedData["params"]["TableName"])
    if not Table.data:
        return {"code": 1, "msg": "找不到表格"}, 404

    ctx = FormData.PM._build_context(Table, _CleanedData["params"]["TableName"], _CleanedData)

    if not FormData.PM.check_permission("get", ctx):
        return {"code": 403, "msg": "无查询权限"}, 403

    skip, custom_result = FormData.PM.run_before_get(ctx)
    if skip:
        return custom_result

    Keys = Table.RangeItemList()

    PageIndex = max(flask.request.args.get("PageIndex", 1, type=int), 1)
    PageSize = min(flask.request.args.get("PageSize", 10, type=int), 100)

    filters = []

    if Table.IsCompositeKey:
        pk_values = {}
        all_pk_present = True
        for pk in Table.PrimaryKeys:
            pk_val = flask.request.args.get(pk)
            if pk_val:
                pk_values[pk] = pk_val
            else:
                all_pk_present = False
                break

        if all_pk_present and pk_values:
            for pk, pk_val in pk_values.items():
                filters.append(
                    getattr(Table.Model, pk) == Table.KeyToUUIDConversion(pk, pk_val, bytes)
                )
    elif Table.PrimaryKey in flask.request.args:
        filters.append(
            getattr(Table.Model, Table.PrimaryKey) == Table.KeyToUUIDConversion(
                Table.PrimaryKey,
                flask.request.args.get(Table.PrimaryKey),
                bytes
            )
        )

    for key in flask.request.args:
        if key.startswith("_") or key in ("PageIndex", "PageSize", "sort", "order", "time", Table.PrimaryKey):
            continue
        if Table.IsCompositeKey and key in Table.PrimaryKeys:
            continue
        if hasattr(Table.Model, key):
            col = getattr(Table.Model, key)
            val = flask.request.args.get(key)
            if val is not None and val != "":
                col_type = str(col.type.__class__.__name__)
                if "BINARY" in col_type:
                    try:
                        filters.append(col == Table.KeyToUUIDConversion(key, val, bytes))
                    except:
                        pass
                elif "Integer" in col_type or "SmallInteger" in col_type:
                    try:
                        filters.append(col == int(val))
                    except:
                        pass
                elif "String" in col_type:
                    filters.append(col == val)

    query = Table.Model.query
    if filters:
        query = query.filter(*filters)

    sort_field = flask.request.args.get("sort", None)
    sort_order = flask.request.args.get("order", "asc").lower()

    time_sort = flask.request.args.get("time", None)
    if time_sort:
        sort_field = "create_time"
        sort_order = time_sort.lower()

    if not sort_field:
        for key, value in flask.request.args.items():
            if hasattr(Table.Model, key) and value.lower() in ["asc", "desc", "dasc"]:
                sort_field = key
                sort_order = value.lower()
                break

    if sort_order not in ["asc", "desc", "dasc"]:
        sort_order = "asc"

    if sort_order == "dasc":
        sort_order = "desc"

    if sort_field and hasattr(Table.Model, sort_field):
        if sort_order == "desc":
            query = query.order_by(getattr(Table.Model, sort_field).desc())
        else:
            query = query.order_by(getattr(Table.Model, sort_field).asc())

    pagination = query.paginate(page=PageIndex, per_page=PageSize, error_out=False)

    user_tz = FormData.get_user_timezone()

    result = {
        "code": 0,
        "total": pagination.total,
        "data": [
            {
                key: (
                    FormData.utc_to_user_tz(getattr(item, key), user_tz).strftime(TableItem.get("TimestampFormat", FSR.ParameterValidator.DEFAULT_TIMESTAMP_STR_FORMAT))
                    if (TableItem := Table.GetItem(key)) and TableItem.get("Type") == "timestampstr" and getattr(item, key) else
                    Table.KeyToUUIDConversion(key, getattr(item, key), str)
                    if hasattr(item, key) else
                    None
                )
                for key in Keys
            } for item in pagination.items
        ]
    }, 200

    modified_result, skip_response = FormData.PM.run_after_get(ctx, result)
    if skip_response:
        return modified_result
    return result