import { SYSTEM_SERVICE_PREFIX } from '@/constants/service';
import { request } from '../request';
import type { ServiceRequestResult } from './shared';
import UserManagementRelationQueryReqVO = Api.SystemManage.UserManagementRelationQueryReqVO;

const ROLE_PREFIX = `${SYSTEM_SERVICE_PREFIX}/role`;
const MENU_PREFIX = `${SYSTEM_SERVICE_PREFIX}/menu`;
const PERMISSION_PREFIX = `${SYSTEM_SERVICE_PREFIX}/permission`;
const USER_PREFIX = `${SYSTEM_SERVICE_PREFIX}/user`;
const DEPT_PREFIX = `${SYSTEM_SERVICE_PREFIX}/dept`;
const POST_PREFIX = `${SYSTEM_SERVICE_PREFIX}/post`;
const ORG_LEADER_PREFIX = `${SYSTEM_SERVICE_PREFIX}/org-leader`;
const USER_MANAGEMENT_RELATION_PREFIX = `${SYSTEM_SERVICE_PREFIX}/user-management-relation`;

function createRolePageQuery(params?: Api.SystemManage.RoleSearchParams) {
  const query = new URLSearchParams();

  if (!params) {
    return query.toString();
  }

  if (params.pageNo !== undefined) {
    query.append('pageNo', String(params.pageNo));
  }

  if (params.pageSize !== undefined) {
    query.append('pageSize', String(params.pageSize));
  }

  if (params.name) {
    query.append('name', params.name);
  }

  if (params.code) {
    query.append('code', params.code);
  }

  if (params.status !== undefined) {
    query.append('status', String(params.status));
  }

  params.createTime?.forEach(item => {
    if (item) {
      query.append('createTime', item);
    }
  });

  return query.toString();
}

function createBatchDeleteQuery(ids: number[]) {
  const query = new URLSearchParams();

  ids.forEach(id => {
    query.append('ids', String(id));
  });

  return query.toString();
}

/** 获取角色分页 */
export function fetchGetRolePage(params?: Api.SystemManage.RoleSearchParams) {
  const query = createRolePageQuery(params);

  return request<Api.SystemManage.RoleList>({
    url: query ? `${ROLE_PREFIX}/page?${query}` : `${ROLE_PREFIX}/page`,
    method: 'get'
  });
}

/** 为兼容旧代码保留原函数名 */
export const fetchGetRoleList = fetchGetRolePage;

/** 获取角色详情 */
export function fetchGetRole(id: number) {
  return request<Api.SystemManage.Role>({
    url: `${ROLE_PREFIX}/get`,
    method: 'get',
    params: { id }
  });
}

/** 创建角色 */
export function fetchCreateRole(data: Api.SystemManage.SaveRoleParams) {
  return request<number>({
    url: `${ROLE_PREFIX}/create`,
    method: 'post',
    data
  });
}

/** 更新角色 */
export function fetchUpdateRole(data: { id: number } & Api.SystemManage.SaveRoleParams) {
  return request<boolean>({
    url: `${ROLE_PREFIX}/update`,
    method: 'put',
    data
  });
}

/** 删除角色 */
export function fetchDeleteRole(id: number) {
  return request<boolean>({
    url: `${ROLE_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/** 批量删除角色 */
export function fetchBatchDeleteRole(ids: number[]) {
  return request<boolean>({
    url: `${ROLE_PREFIX}/delete-list?${createBatchDeleteQuery(ids)}`,
    method: 'delete'
  });
}

/**
 * 获取全部角色
 *
 * 为当前用户页面保留 `roleName / roleCode` 字段，直到该页面完成重构
 */
export async function fetchGetAllRoles(): Promise<ServiceRequestResult<Api.SystemManage.AllRole[]>> {
  const result = await request<Api.SystemManage.RoleSimpleList>({
    url: `${ROLE_PREFIX}/simple-list`,
    method: 'get'
  });

  if (result.error || !result.data) {
    return result as ServiceRequestResult<Api.SystemManage.AllRole[]>;
  }

  return {
    ...result,
    data: result.data.map(item => ({
      ...item,
      roleName: item.name,
      roleCode: item.code
    }))
  };
}

/** 获取启用状态的角色简表 */
export function fetchGetRoleSimpleList() {
  return request<Api.SystemManage.RoleSimpleList>({
    url: `${ROLE_PREFIX}/simple-list`,
    method: 'get'
  });
}

/** 获取部门列表 */
export function fetchGetDeptList(params?: Api.SystemManage.DeptSearchParams) {
  return request<Api.SystemManage.DeptList>({
    url: `${DEPT_PREFIX}/list`,
    method: 'get',
    params
  });
}

/** 获取部门简表 */
export function fetchGetDeptSimpleList() {
  return request<Api.SystemManage.DeptSimpleList>({
    url: `${DEPT_PREFIX}/simple-list`,
    method: 'get'
  });
}

/** 创建部门 */
export function fetchCreateDept(data: Api.SystemManage.SaveDeptParams) {
  return request<number>({
    url: `${DEPT_PREFIX}/create`,
    method: 'post',
    data
  });
}

/** 更新部门 */
export function fetchUpdateDept(data: { id: number } & Api.SystemManage.SaveDeptParams) {
  return request<boolean>({
    url: `${DEPT_PREFIX}/update`,
    method: 'put',
    data
  });
}

/** 删除部门 */
export function fetchDeleteDept(id: number) {
  return request<boolean>({
    url: `${DEPT_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/** 根据部门获取组织负责人关系 */
export function fetchGetOrgLeaderListByDept(deptId: number) {
  return request<Api.SystemManage.OrgLeaderRelationList>({
    url: `${ORG_LEADER_PREFIX}/list-by-dept`,
    method: 'get',
    params: { deptId }
  });
}

/** 获取组织负责人的候选用户 */
export function fetchGetOrgLeaderCandidateUsers(deptId: number) {
  return request<Api.SystemManage.OrgLeaderCandidateUserList>({
    url: `${ORG_LEADER_PREFIX}/candidate-users`,
    method: 'get',
    params: { deptId }
  });
}

/** 创建组织负责人关系 */
export function fetchCreateOrgLeaderRelation(data: Api.SystemManage.SaveOrgLeaderRelationParams) {
  return request<number>({
    url: `${ORG_LEADER_PREFIX}/create`,
    method: 'post',
    data
  });
}

/** 更新组织负责人关系 */
export function fetchUpdateOrgLeaderRelation(data: { id: number } & Api.SystemManage.SaveOrgLeaderRelationParams) {
  return request<boolean>({
    url: `${ORG_LEADER_PREFIX}/update`,
    method: 'put',
    data
  });
}

/** 删除组织负责人关系 */
export function fetchDeleteOrgLeaderRelation(id: number) {
  return request<boolean>({
    url: `${ORG_LEADER_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/** 获取启用状态的岗位简表 */
export function fetchGetPostSimpleList() {
  return request<Api.SystemManage.PostSimpleList>({
    url: `${POST_PREFIX}/simple-list`,
    method: 'get'
  });
}

/** 获取岗位分页 */
export function fetchGetPostPage(params?: Api.SystemManage.PostSearchParams) {
  return request<Api.SystemManage.PostList>({
    url: `${POST_PREFIX}/page`,
    method: 'get',
    params
  });
}

/** 获取岗位详情 */
export function fetchGetPost(id: number) {
  return request<Api.SystemManage.Post>({
    url: `${POST_PREFIX}/get`,
    method: 'get',
    params: { id }
  });
}

/** 创建岗位 */
export function fetchCreatePost(data: Api.SystemManage.SavePostParams) {
  return request<number>({
    url: `${POST_PREFIX}/create`,
    method: 'post',
    data
  });
}

/** 更新岗位 */
export function fetchUpdatePost(data: { id: number } & Api.SystemManage.SavePostParams) {
  return request<boolean>({
    url: `${POST_PREFIX}/update`,
    method: 'put',
    data
  });
}

/** 删除岗位 */
export function fetchDeletePost(id: number) {
  return request<boolean>({
    url: `${POST_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/** 批量删除岗位 */
export function fetchBatchDeletePost(ids: number[]) {
  return request<boolean>({
    url: `${POST_PREFIX}/delete-list?${createBatchDeleteQuery(ids)}`,
    method: 'delete'
  });
}

/** 获取用户简单列表（用于用户选择下拉框） */
export function fetchGetUserSimpleList() {
  return request<Api.SystemManage.UserSimple[]>({
    url: `${USER_PREFIX}/simple-list`,
    method: 'get'
  });
}

/** 获取用户分页 */
export function fetchGetUserPage(params?: Api.SystemManage.UserSearchParams) {
  return request<Api.SystemManage.UserList>({
    url: `${USER_PREFIX}/page`,
    method: 'get',
    params
  });
}

/** 为兼容旧代码保留原函数名 */
export const fetchGetUserList = fetchGetUserPage;

/** 通过部门id获取用户详情 */
export function fetchGetUserListByDeptId(deptId: any) {
  return request<Api.SystemManage.UserSimple[]>({
    url: `${USER_PREFIX}/list-by-dept-id`,
    method: 'get',
    params: { deptId }
  });
}

/** 获取用户详情 */
export function fetchGetUser(id: number) {
  return request<Api.SystemManage.User>({
    url: `${USER_PREFIX}/get`,
    method: 'get',
    params: { id }
  });
}

/** 创建用户 */
export function fetchCreateUser(data: Api.SystemManage.SaveUserParams) {
  return request<number>({
    url: `${USER_PREFIX}/create`,
    method: 'post',
    data
  });
}

/** 更新用户 */
export function fetchUpdateUser(data: { id: number } & Api.SystemManage.SaveUserParams) {
  return request<boolean>({
    url: `${USER_PREFIX}/update`,
    method: 'put',
    data
  });
}

/** 更新用户状态 */
export function fetchUpdateUserStatus(data: Api.SystemManage.UpdateUserStatusParams) {
  return request<boolean>({
    url: `${USER_PREFIX}/update-status`,
    method: 'put',
    data
  });
}

/** 重置用户密码 */
export function fetchUpdateUserPassword(data: Api.SystemManage.UpdateUserPasswordParams) {
  return request<boolean>({
    url: `${USER_PREFIX}/update-password`,
    method: 'put',
    data
  });
}

/** 删除用户 */
export function fetchDeleteUser(id: number) {
  return request<boolean>({
    url: `${USER_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/** 批量删除用户 */
export function fetchBatchDeleteUser(ids: number[]) {
  return request<boolean>({
    url: `${USER_PREFIX}/delete-list?${createBatchDeleteQuery(ids)}`,
    method: 'delete'
  });
}

/** 获取菜单列表 */
export function fetchGetMenuList(params?: Api.SystemManage.MenuSearchParams) {
  return request<Api.SystemManage.MenuList>({
    url: `${MENU_PREFIX}/list`,
    method: 'get',
    params
  });
}

/** 获取菜单详情 */
export function fetchGetMenu(id: number) {
  return request<Api.SystemManage.Menu>({
    url: `${MENU_PREFIX}/get`,
    method: 'get',
    params: { id }
  });
}

/** 创建菜单 */
export function fetchCreateMenu(data: Api.SystemManage.SaveMenuParams) {
  return request<number>({
    url: `${MENU_PREFIX}/create`,
    method: 'post',
    data
  });
}

/** 更新菜单 */
export function fetchUpdateMenu(data: { id: number } & Api.SystemManage.SaveMenuParams) {
  return request<boolean>({
    url: `${MENU_PREFIX}/update`,
    method: 'put',
    data
  });
}

/** 删除菜单 */
export function fetchDeleteMenu(id: number) {
  return request<boolean>({
    url: `${MENU_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/** 批量删除菜单 */
export function fetchBatchDeleteMenu(ids: number[]) {
  return request<boolean>({
    url: `${MENU_PREFIX}/delete-list?${createBatchDeleteQuery(ids)}`,
    method: 'delete'
  });
}

/** 获取启用状态的菜单简表 */
export function fetchGetMenuSimpleList() {
  return request<Api.SystemManage.MenuSimpleList>({
    url: `${MENU_PREFIX}/simple-list`,
    method: 'get'
  });
}

/** 获取角色关联的菜单 ID 列表 */
export function fetchGetRoleMenuIds(roleId: number) {
  return request<number[]>({
    url: `${PERMISSION_PREFIX}/list-role-menus`,
    method: 'get',
    params: { roleId }
  });
}

/** 分配角色菜单 */
export function fetchAssignRoleMenus(data: Api.SystemManage.AssignRoleMenuParams) {
  return request<boolean>({
    url: `${PERMISSION_PREFIX}/assign-role-menu`,
    method: 'post',
    data
  });
}

/** 获取用户关联的角色 ID 列表 */
export function fetchGetUserRoleIds(userId: number) {
  return request<number[]>({
    url: `${PERMISSION_PREFIX}/list-user-roles`,
    method: 'get',
    params: { userId }
  });
}

/** 分配用户角色 */
export function fetchAssignUserRoles(data: Api.SystemManage.AssignUserRoleParams) {
  return request<boolean>({
    url: `${PERMISSION_PREFIX}/assign-user-role`,
    method: 'post',
    data
  });
}

// ==================== 用户管理链路相关 API ====================
/**
 * 获取用户管理链路树形结构
 *
 * 用于树形控件展示，包含用户的上下级层级关系
 * 树形结构特点：
 * - 根节点：最高领导，没有上级
 * - 中间节点：有上级也有下级
 * - 叶子节点：基层员工，没有下级
 */
export function fetchGetUserManagementRelationTree(query: UserManagementRelationQueryReqVO) {
  return request<Api.SystemManage.UserManagementRelationTreeRespVO[]>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/tree`,
    method: 'get',
    params: query
  });
}

/**
 * 通过搜索框的查询条件，获取用户管理链路树形结构
 * 用于树形控件展示，包含用户的上下级层级关系
 */
export function fetchGetUserManagementRelationQuery(query: UserManagementRelationQueryReqVO) {
  return request<Api.SystemManage.UserManagementRelationTreeRespVO[]>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/query`,
    method: 'get',
    params: query
  });
}

/**
 * 获取用户管理链路详情
 *
 * 根据主键 ID 查询单条用户管理链路记录
 *
 * @param id 关系记录主键 ID
 */
export function fetchGetUserManagementRelation(id: number) {
  return request<Api.SystemManage.UserManagementRelation>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/get`,
    method: 'get',
    params: { id }
  });
}

/**
 * 创建用户管理链路
 *
 * 创建新的用户管理链路记录
 *
 * @param data 创建请求参数
 */
export function fetchCreateUserManagementRelation(data: Api.SystemManage.UserManagementRelationSaveReqVO) {
  return request<number>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/create`,
    method: 'post',
    data
  });
}

/**
 * 更新用户管理链路
 *
 * 更新已有的用户管理链路记录
 *
 * @param data 更新请求参数（包含 id）
 */
export function fetchUpdateUserManagementRelation(
  data: { id: number } & Api.SystemManage.UserManagementRelationSaveReqVO
) {
  return request<boolean>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/update`,
    method: 'put',
    data
  });
}

/**
 * 删除用户管理链路
 *
 * 根据主键 ID 删除单条用户管理链路记录
 *
 * @param id 关系记录主键 ID
 */
export function fetchDeleteUserManagementRelation(id: number | null) {
  return request<boolean>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/delete`,
    method: 'delete',
    params: { id }
  });
}

/**
 * 批量删除用户管理链路
 *
 * 根据主键 ID 列表批量删除用户管理链路记录
 *
 * @param ids 关系记录主键 ID 列表
 */
export function fetchBatchDeleteUserManagementRelation(ids: number[]) {
  return request<boolean>({
    url: `${USER_MANAGEMENT_RELATION_PREFIX}/delete-list?${createBatchDeleteQuery(ids)}`,
    method: 'delete'
  });
}