from fastapi import APIRouter, Depends, Query

from config.security import get_user_id_from_token
from db.postgres.system import *
from models.BaseResponse import BaseResponse
from utils.MyUtils import build_dept_tree, format_datetime, build_menu_tree

systemRouter = APIRouter()


@systemRouter.get("/dept/list")
async def dept_list(user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}

    depts = get_all_depts()

    # 字段映射（关键）
    for d in depts:
        # 映射字段
        d["pid"] = d.pop("parent_id") or 0  # ！！！null → 0
        d["remark"] = d.pop("comment")
        d["createTime"] = format_datetime(d.pop("created_at"))

        # 前端示例格式要求有 status 字段
        d["status"] = 1

        # children 初始化
        d["children"] = []

    # 构建树
    tree = build_dept_tree(depts)

    return BaseResponse(data=tree)


@systemRouter.post("/dept/add")
async def dept_add(data: dict, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}

    parent_id = data.get("pid")
    name = data.get("name")
    comment = data.get("remark")

    if not name:
        return BaseResponse(status=False, message="部门名不能为空", data=None)

    new_id = insert_dept(parent_id, name, comment)

    return BaseResponse(data={"id": new_id})


@systemRouter.put("/dept/{id}")
async def dept_update(
    id: str, data: dict, user_id: UUID = Depends(get_user_id_from_token)
):
    if not user_id:
        return {"error": "userId is required"}

    parent_id = data.get("pid")
    name = data.get("name")
    comment = data.get("remark")

    rowcount = update_dept(id, parent_id, name, comment)
    if rowcount == 0:
        return BaseResponse(status=False, message="部门不存在", data=None)

    return BaseResponse(data=True)


@systemRouter.delete("/dept/{id}")
async def dept_dept(id: str, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}

    if has_child_dept(id):
        return BaseResponse(status=False, message="禁止删除：请先删除子部门", data=None)

    deleted = delete_dept(id)
    if deleted == 0:
        return BaseResponse(status=False, message="部门不存在", data=None)

    return BaseResponse(data=True)


from fastapi import Depends
from uuid import UUID


@systemRouter.get("/menu/list/{plat_id}")
async def menu_list(plat_id: int, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}

    # 1. 根据用户ID获取角色ID列表
    role_ids = get_role_ids_by_user(user_id)
    if not role_ids:
        BaseResponse(data=[])  # 用户没有角色，则返回空列表

    # 2. 根据角色ID获取菜单ID列表
    menu_ids = get_menu_ids_by_roles(role_ids)
    if not menu_ids:
        BaseResponse(data=[])  # 角色没有菜单权限，则返回空列表

    # 3. 查询菜单信息
    menus = get_menus_by_ids(menu_ids, plat_id)

    # 4. 字段映射，兼容前端
    for m in menus:
        m["pid"] = m.get("pid") or "0"
        m["meta"] = m.get("meta") or {}
        m["createTime"] = format_datetime(m.get("created_at"))
        m["updateTime"] = format_datetime(m.get("updated_at"))
        m["children"] = []
        # 删除created_at updated_at
        m.pop("createTime", None)
        m.pop("updateTime", None)

    # 5. 构建菜单树
    tree = build_menu_tree(menus)
    return BaseResponse(data=tree)


@systemRouter.get("/menu/list/all/{plat_id}")
async def menu_list_all(plat_id: int, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    if plat_id == -1:
        menus = get_all_menus()
    else:
        menus = get_menus(plat_id)

    # 字段映射
    for m in menus:
        m["pid"] = m.pop("pid") or "0"
        m["meta"] = m["meta"] or {}
        m["createTime"] = format_datetime(m.pop("created_at"))
        m["updateTime"] = format_datetime(m.pop("updated_at"))
        m["children"] = []

    # 构建树，与 build_dept_tree 同逻辑
    tree = build_menu_tree(menus)

    return BaseResponse(data=tree)


@systemRouter.get("/menu/name-exists/{plat_id}")
async def menu_name_exists(
    plat_id: int,
    name: str,
    id: str | None = None,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    exists = db_menu_name_exists(name, id, plat_id)
    return BaseResponse(data=exists)


@systemRouter.get("/menu/path-exists/{plat_id}")
async def menu_path_exists(
    plat_id: int,
    path: str,
    id: str | None = None,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    exists = db_menu_path_exists(path, id, plat_id)
    return BaseResponse(data=exists)


@systemRouter.post("/menu/{plat_id}")
async def create_menu(
    plat_id: int, data: dict, user_id: UUID = Depends(get_user_id_from_token)
):
    if not user_id:
        return {"error": "userId is required"}

    new_id = insert_menu(data, plat_id)
    return BaseResponse(data={"id": new_id})


@systemRouter.put("/menu/{id}")
async def update_menu(
    id: str,
    data: dict,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    count = update_menu_db(id, data)
    if count == 0:
        return BaseResponse(status=False, message="菜单不存在", data=None)

    return BaseResponse(data=True)


@systemRouter.delete("/menu/{id}")
async def delete_menu(
    id: str,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    if menu_has_children(id):
        return BaseResponse(status=False, message="禁止删除：请先删除子菜单", data=None)

    deleted = delete_menu_db(id)
    if deleted == 0:
        return BaseResponse(status=False, message="菜单不存在", data=None)

    return BaseResponse(data=True)


@systemRouter.get("/role/name-exists")
async def role_name_exists(
    name: str,
    id: str | None = None,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}
    exists = db_role_name_exists(name, id)
    return BaseResponse(data=exists)


@systemRouter.get("/role/all")
async def get_role_list(user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    roles = get_role_list_db()
    return BaseResponse(data=roles)


@systemRouter.get("/role/list")
async def get_role_list(
    page: int = 1,
    pageSize: int = 10,
    id: str | None = None,
    name: str | None = None,
    remark: str | None = None,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    roles, total = get_role_list_db_page(page, pageSize, id, name, remark)

    return BaseResponse(data={"list": roles, "total": total})


@systemRouter.post("/role")
async def create_role(data: dict, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    new_id = insert_role(data)
    return BaseResponse(data={"id": new_id})


@systemRouter.put("/role/{id}")
async def update_role(
    id: str,
    data: dict,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    count = update_role_db(id, data)
    if count == 0:
        return BaseResponse(status=False, message="角色不存在", data=None)

    return BaseResponse(data=True)


@systemRouter.delete("/role/{id}")
async def delete_role(
    id: str,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    deleted = delete_role_db(id)
    if deleted == 0:
        return BaseResponse(status=False, message="角色不存在", data=None)

    return BaseResponse(data=True)


@systemRouter.get("/user/name-exists")
async def user_name_exists(
    username: str,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}
    exists = db_user_name_exists(username)
    return BaseResponse(data=exists)


@systemRouter.get("/user/list")
async def get_user_list(
    page: int = 1,
    pageSize: int = 10,
    id: str | None = None,
    name: str | None = None,
    status: int | None = None,
    dept_id: str | None = None,
    startTime: str | None = None,
    endTime: str | None = None,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    users, total = get_user_list_db_page(
        page, pageSize, id, name, status, dept_id, startTime, endTime
    )

    return BaseResponse(data={"list": users, "total": total})


@systemRouter.post("/user")
async def create_user(data: dict, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    new_id = insert_user(data)
    return BaseResponse(data={"id": new_id})


@systemRouter.patch("/user/{id}")
async def patch_user(
    id: str,
    data: dict,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    count = patch_user_db(id, data)
    if count == 0:
        return BaseResponse(status=False, message="用户不存在", data=None)
    return BaseResponse(data=True)


@systemRouter.delete("/user/{id}")
async def delete_user(
    id: str,
    user_id: UUID = Depends(get_user_id_from_token),
):
    if not user_id:
        return {"error": "userId is required"}

    deleted = delete_user_db(id)
    if deleted == 0:
        return BaseResponse(status=False, message="用户不存在", data=None)
    return BaseResponse(data=True)


@systemRouter.get("/dict/list")
def getScVideoList(
    user_id: UUID = Depends(get_user_id_from_token),
    name: str = "",
    page: int = Query(1, ge=1),
    page_size: int = Query(10, ge=1, le=100),
):
    if not user_id:
        return {"error": "userId is required"}
    total, items = get_dict_list(name, page=page, page_size=page_size)
    return BaseResponse(
        data={
            "total": total,
            "items": items,
        }
    )


@systemRouter.post("/dict")
def create_dict_api(data: dict, user_id: UUID = Depends(get_user_id_from_token)):
    """
    创建字典接口
    data = { "key": str, "name": str, "remark": str }
    """
    if not user_id:
        return {"error": "userId is required"}

    new_id = db_create_dict(data.get("key"), data.get("name"), data.get("remark"))
    return BaseResponse(data={"id": new_id})


@systemRouter.put("/dict/{id}")
def update_dict_api(
    id: str, data: dict, user_id: UUID = Depends(get_user_id_from_token)
):
    """
    更新字典接口
    """
    if not user_id:
        return {"error": "userId is required"}

    db_update_dict(id, data.get("key"), data.get("name"), data.get("remark"))
    return BaseResponse(data={"id": id})


@systemRouter.delete("/dict/{id}")
def delete_dict_api(id: str, user_id: UUID = Depends(get_user_id_from_token)):
    """
    删除字典接口
    """
    if not user_id:
        return {"error": "userId is required"}

    db_delete_dict(id)
    return BaseResponse(data={"id": id})


@systemRouter.get("/dict/detail/list")
def get_dict_detail_api(dictId: str, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    items = db_get_dict_detail(dictId)
    return BaseResponse(data={"list": items})


@systemRouter.post("/dict/detail")
def create_dict_detail_api(data: dict, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    new_id = db_create_dict_detail(
        value=data.get("value"),
        dict_id=data.get("dict_id"),
        sort=data.get("sort", 0),
        pid=data.get("pid"),
        remark=data.get("remark"),
    )
    return BaseResponse(data={"id": new_id})


@systemRouter.put("/dict/detail/{id}")
def update_dict_detail_api(
    id: str, data: dict, user_id: UUID = Depends(get_user_id_from_token)
):
    if not user_id:
        return {"error": "userId is required"}
    db_update_dict_detail(
        id=id,
        value=data.get("value"),
        sort=data.get("sort"),
        pid=data.get("pid"),
        remark=data.get("remark"),
    )
    return BaseResponse(data={"id": id})


@systemRouter.delete("/dict/detail/{id}")
def delete_dict_detail_api(id: str, user_id: UUID = Depends(get_user_id_from_token)):
    if not user_id:
        return {"error": "userId is required"}
    db_delete_dict_detail(id)
    return BaseResponse(data={"id": id})


@systemRouter.get("/dict/getValue")
def get_dict_detail_by_key(
    key: str = Query(..., min_length=1),
):
    if not key:
        return {"error": "key is required"}

    items = get_dict_detail_list_by_key(key)

    return BaseResponse(data=items)