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


def VerifyForm(TableName, **kwargs):
    Table = FormData.GetTable(TableName)
    if not Table:
        return {"code": 1, "msg": "找不到表格"}, 404
    fields = Table.Get()
    for field in fields:
        field["PassEmpty"] = True
    return fields


__metadata__ = {
    "route": "{DEFAULT_ROUTE}/<TableName>/<id>",
    "methods": ["PUT"],
    "blueprint": "GERP",
    "permission": 3.0,
    "attributes": [],
    "limit": "1 per second",
    "form": VerifyForm
}


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

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

    if not FormData.PM.check_permission("modify", ctx):
        return {"code": 403, "msg": "无修改权限"}, 403

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

    pk_value = _CleanedData["params"].get("id") or _CleanedData["form"].get(Table.PrimaryKey)
    if not pk_value:
        return {"code": 1, "msg": "缺少主键"}, 400

    pk_parts = [p.strip() for p in str(pk_value).split(',')]
    if len(pk_parts) > 1:
        filters = []
        for i, pk_name in enumerate(Table.PrimaryKeys):
            if i < len(pk_parts):
                filters.append(
                    getattr(Table.Model, pk_name) == Table.KeyToUUIDConversion(
                        pk_name, pk_parts[i], bytes
                    )
                )
        Model = Table.Model.query.filter(*filters).first()
    else:
        Model = Table.Model.query.filter(
            getattr(Table.Model, Table.PrimaryKey) == Table.KeyToUUIDConversion(
                Table.PrimaryKey, pk_value, bytes
            )
        ).first()
    if not Model:
        return {"code": 1, "msg": "找不到记录"}, 404

    for i in Table.RangeItem():
        if i == Table.PrimaryKey:
            continue
        if i not in _CleanedData["form"]:
            continue
        field_config = Table.GetItem(i)
        value = _CleanedData["form"][i]

        if value is None or (isinstance(value, str) and not value.strip()):
            if field_config and field_config.get("Type") == "UUID":
                setattr(Model, i, None)
            continue

        if field_config:
            field_type = field_config.get("Type")

            if field_type == "int":
                try:
                    value = int(value)
                except (ValueError, TypeError):
                    continue
            elif field_type == "float":
                try:
                    value = float(value)
                except (ValueError, TypeError):
                    continue
            elif field_type == "bool":
                value = bool(value)
            elif field_type == "UUID":
                if not value:
                    setattr(Model, i, None)
                    continue
                value = Table.KeyToUUIDConversion(i, value, bytes)
            elif field_type == "timestampstr":
                utc_str = FormData.user_tz_to_utc(value)
                ts_format = field_config.get("TimestampFormat", "%Y-%m-%d %H:%M:%S")
                try:
                    value = datetime.datetime.strptime(utc_str, "%Y-%m-%d %H:%M:%S")
                except ValueError:
                    try:
                        value = datetime.datetime.strptime(utc_str, ts_format)
                    except ValueError:
                        continue
            elif field_type == "json":
                if isinstance(value, str):
                    try:
                        import json
                        value = json.loads(value)
                    except json.JSONDecodeError:
                        continue

            setattr(Model, i, value)
        else:
            if value is not None and not (isinstance(value, str) and not value.strip()):
                try:
                    int(value)
                    setattr(Model, i, value)
                except (ValueError, TypeError):
                    setattr(Model, i, Table.KeyToUUIDConversion(i, value, bytes))

    table_data = FormData.data.get(_CleanedData["params"]["TableName"])
    if table_data and "config" in table_data and "autoFill" in table_data["config"]:
        auto_fill = table_data["config"]["autoFill"]
        current_user = GetELTUser()
        if current_user:
            for field, value in auto_fill.items():
                if value == "current_user" and field not in _CleanedData["form"]:
                    setattr(Model, field, Get16toBytes(current_user.GetUserUUID()))

    try:
        db.session.commit()
        result = {"code": 0, "msg": "更新成功"}, 200
    except Exception as e:
        db.session.rollback()
        import traceback
        traceback.print_exc()
        result = {"code": 1, "msg": f"更新失败：{str(e)}"}, 500

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