import { get } from '../axios-client';
import { API_BASE_URL } from '../../config/api-config';
import axios from 'axios';

// 组织路径信息（懒加载接口返回）
export interface OrganizationPath {
  tenant_name: string;
  dep_name: string;
  dep_short_name: string;
  ou_name: string;
}

// 用户信息接口（新版，匹配 /api/v2/users 响应）
export interface UserInfo {
  id: number;
  username: string;
  nick_name: string;
  area: string;
  ou_id: string;
  ou_name: string;
  is_leader: boolean;
  status: number;
  // 以下字段在搜索接口中有值，在懒加载接口中为 null
  tenant_name: string | null;
  dep_name: string | null;
  dep_short_name: string | null;
  email?: string;
  phone_number?: string;
  // 懒加载接口返回的组织路径信息
  organization_path?: OrganizationPath | null;
}

// 组织节点接口（新版，匹配 /api/v2/users/organizations/tree 响应）
export interface OrganizationNode {
  ou_id: string;
  ou_name: string;
  parent_ou_id: string | null;
  level: number;
  children: OrganizationNode[];
  users: UserInfo[];
}

// 组织架构响应接口
export interface OrganizationResponse {
  organizations: OrganizationNode[];
  total_organizations: number;
  total_users: number;
}

// 用户列表响应接口
export interface UserListResponse {
  users: UserInfo[];
  total: number;
}

// API响应格式
export interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: string;
  message?: string;
  status?: number;
}

type RbacUserRole = {
  role_id?: number;
  role_key?: string;
  role_name?: string;
};

type RbacUserItem = {
  id: number;
  username: string;
  nick_name: string;
  area: string;
  ou_id: string | null;
  ou_name: string | null;
  is_leader: boolean;
  status: number;
  tenant_name: string | null;
  dep_name: string | null;
  dep_short_name?: string | null;
  email?: string | null;
  phone_number?: string | null;
  roles?: RbacUserRole[];
};

type RbacUsersPayload = {
  total: number;
  page: number;
  page_size: number;
  items: RbacUserItem[];
};

let rbacUsersAvailable: boolean | null = null;

function normalizeUser(user: RbacUserItem): UserInfo {
  return {
    id: user.id,
    username: user.username,
    nick_name: user.nick_name,
    area: user.area,
    ou_id: user.ou_id || '',
    ou_name: user.ou_name || '',
    is_leader: Boolean(user.is_leader),
    status: Number(user.status ?? 0),
    tenant_name: user.tenant_name ?? null,
    dep_name: user.dep_name ?? null,
    dep_short_name: user.dep_short_name ?? null,
    email: user.email ?? undefined,
    phone_number: user.phone_number ?? undefined,
    organization_path: {
      tenant_name: user.tenant_name || '未分组租户',
      dep_name: user.dep_name || '未分组部门',
      dep_short_name: user.dep_short_name || user.dep_name || '未分组部门',
      ou_name: user.ou_name || '未分组组织',
    },
  };
}

async function fetchRbacUsers(
  jwtToken?: string,
  search?: string,
): Promise<ApiResponse<RbacUsersPayload>> {
  try {
    const params = new URLSearchParams();
    params.set('page', '1');
    params.set('pageSize', '5000');
    const headers: Record<string, string> = {
      'Content-Type': 'application/json',
    };
    if (jwtToken) {
      headers.Authorization = `Bearer ${jwtToken}`;
    }

    const response = await axios.get<{ code?: number; message?: string; data?: RbacUsersPayload }>(
      `${API_BASE_URL}/api/v3/rbac/users?${params.toString()}`,
      { headers },
    );

    if (!response.data?.data) {
      return {
        success: false,
        error: response.data?.message || '用户列表返回为空',
      };
    }

    const keyword = search?.trim().toLowerCase();
    const items = keyword
      ? response.data.data.items.filter((item) => {
          const haystacks = [
            item.username,
            item.nick_name,
            item.area,
            item.tenant_name,
            item.dep_name,
            item.ou_name,
          ];
          return haystacks.some((value) => value?.toLowerCase().includes(keyword));
        })
      : response.data.data.items;

    return {
      success: true,
      data: {
        ...response.data.data,
        total: items.length,
        items,
      },
    };
  } catch (error) {
    let errorMessage = '获取用户列表失败';
    if (axios.isAxiosError(error)) {
      errorMessage = error.response?.data?.detail || error.response?.data?.message || error.message;
    } else if (error instanceof Error) {
      errorMessage = error.message;
    }
    return {
      success: false,
      error: errorMessage,
    };
  }
}

function buildOrganizationTreeFromUsers(
  users: UserInfo[],
  includeUsers: boolean,
  rootUuid?: string,
): OrganizationResponse {
  const tenantMap = new Map<string, OrganizationNode>();

  const ensureChild = (
    parent: OrganizationNode,
    key: string,
    create: () => OrganizationNode,
  ): OrganizationNode => {
    const existing = parent.children.find((item) => item.ou_id === key);
    if (existing) return existing;
    const next = create();
    parent.children.push(next);
    return next;
  };

  users.forEach((user) => {
    const tenantName = user.tenant_name || user.area || '未分组租户';
    const depName = user.dep_name || '未分组部门';
    const ouId = user.ou_id || `ou_${depName}`;
    const ouName = user.ou_name || depName || '未分组组织';

    const tenantKey = `tenant:${tenantName}`;
    let tenantNode = tenantMap.get(tenantKey);
    if (!tenantNode) {
      tenantNode = {
        ou_id: tenantKey,
        ou_name: tenantName,
        parent_ou_id: null,
        level: 1,
        children: [],
        users: [],
      };
      tenantMap.set(tenantKey, tenantNode);
    }

    const depKey = `dep:${tenantName}:${depName}`;
    const depNode = ensureChild(tenantNode, depKey, () => ({
      ou_id: depKey,
      ou_name: depName,
      parent_ou_id: tenantNode!.ou_id,
      level: 2,
      children: [],
      users: [],
    }));

    const orgKey = ouId.startsWith('ou_') ? `org:${tenantName}:${depName}:${ouName}` : ouId;
    const orgNode = ensureChild(depNode, orgKey, () => ({
      ou_id: orgKey,
      ou_name: ouName,
      parent_ou_id: depNode.ou_id,
      level: 3,
      children: [],
      users: [],
    }));

    if (includeUsers) {
      orgNode.users.push(user);
    }
  });

  const organizations = Array.from(tenantMap.values());
  const pickSubtree = (nodes: OrganizationNode[], target: string): OrganizationNode[] => {
    for (const node of nodes) {
      if (node.ou_id === target) return [node];
      const nested = pickSubtree(node.children || [], target);
      if (nested.length > 0) return nested;
    }
    return [];
  };

  return {
    organizations: rootUuid ? pickSubtree(organizations, rootUuid) : organizations,
    total_organizations: organizations.length,
    total_users: users.length,
  };
}

/**
 * 获取组织架构树（新版接口，支持按需加载）
 * @param includeUsers 是否包含用户信息
 * @param rootUuid 指定根节点UUID，不传则查询所有根节点
 * @param jwtToken JWT Token
 * @returns 组织架构树
 */
export async function getOrganizationTree(
  includeUsers: boolean = false,
  jwtToken?: string,
  rootUuid?: string
): Promise<ApiResponse<OrganizationResponse>> {
  const headers: Record<string, string> = {
    'Content-Type': 'application/json'
  };
  if (jwtToken) {
    headers['Authorization'] = `Bearer ${jwtToken}`;
  }

  try {
    // 新平台直接基于 RBAC 用户列表构造组织树，避免依赖已下线的旧 v2 接口。
    const fallbackUsers = await fetchRbacUsers(jwtToken);
    if (!fallbackUsers.success || !fallbackUsers.data) {
      throw new Error(fallbackUsers.error || '获取组织架构失败');
    }

    rbacUsersAvailable = true;
    const normalizedUsers = fallbackUsers.data.items.map(normalizeUser);
    return {
      success: true,
      data: buildOrganizationTreeFromUsers(normalizedUsers, includeUsers, rootUuid),
    };
  } catch (error) {
    if (rbacUsersAvailable === false) {
      console.error('[getOrganizationTree] 获取组织架构失败:', error);
      return {
        success: false,
        error: error instanceof Error ? error.message : '获取组织架构失败',
      };
    }

    rbacUsersAvailable = false;
  }

  try {
    const params: string[] = [];
    params.push(`include_users=${includeUsers}`);
    if (rootUuid) {
      params.push(`root_uuid=${rootUuid}`);
    }

    const url = `${API_BASE_URL}/api/v2/users/organizations/tree?${params.join('&')}`;
    const response = await axios.get<OrganizationResponse>(url, { headers });
    return {
      success: true,
      data: response.data
    };
  } catch (error) {
    console.error('[getOrganizationTree] 获取组织架构失败:', error);
    let errorMessage = '获取组织架构失败';
    if (axios.isAxiosError(error)) {
      if (error.response?.data?.detail) {
        errorMessage = error.response.data.detail;
      } else if (error.response?.data?.message) {
        errorMessage = error.response.data.message;
      }
    } else if (error instanceof Error) {
      errorMessage = error.message;
    }

    return {
      success: false,
      error: errorMessage
    };
  }
}

/**
 * 搜索用户（新版接口）
 * @param search 搜索关键词（模糊匹配姓名和工号）
 * @param page 页码
 * @param pageSize 每页数量
 * @param jwtToken JWT Token
 * @returns 用户列表
 */
export async function searchUsers(
  search: string,
  page: number = 1,
  pageSize: number = 20,
  jwtToken?: string
): Promise<ApiResponse<{
  users: UserInfo[];
  total: number;
}>> {
  const fallbackUsers = await fetchRbacUsers(jwtToken, search);
  if (!fallbackUsers.success || !fallbackUsers.data) {
    const params: string[] = [];
    if (search) params.push(`search=${encodeURIComponent(search)}`);
    params.push(`page=${page}`);
    params.push(`page_size=${pageSize}`);

    const headers: Record<string, string> = {
      'Content-Type': 'application/json'
    };
    if (jwtToken) {
      headers['Authorization'] = `Bearer ${jwtToken}`;
    }

    try {
      const url = `${API_BASE_URL}/api/v2/users?${params.join('&')}`;
      const response = await axios.get<{ users: UserInfo[]; total: number }>(url, { headers });
      return {
        success: true,
        data: response.data
      };
    } catch (error) {
      console.error('[searchUsers] 搜索用户失败:', error);
      let errorMessage = fallbackUsers.error || '搜索用户失败';
      if (axios.isAxiosError(error)) {
        if (error.response?.data?.detail) {
          errorMessage = error.response.data.detail;
        } else if (error.response?.data?.message) {
          errorMessage = error.response.data.message;
        }
      } else if (error instanceof Error) {
        errorMessage = error.message;
      }

      return {
        success: false,
        error: errorMessage
      };
    }
  }

  const normalized = fallbackUsers.data.items.map(normalizeUser);
  const start = (page - 1) * pageSize;
  const paged = normalized.slice(start, start + pageSize);
  return {
    success: true,
    data: {
      users: paged,
      total: normalized.length,
    }
  };
}

/**
 * 获取用户列表
 * @param params 查询参数
 * @returns 用户列表
 */
export async function getUserList(params: {
  page?: number;
  page_size?: number;
  ou_id?: string;
  is_leader?: boolean;
  status?: number;
  search?: string;
} = {}): Promise<ApiResponse<UserListResponse>> {
  try {
    // console.log('开始调用获取用户列表API，参数:', params);
    
    const queryParams = new URLSearchParams();
    if (params.page) queryParams.append('page', params.page.toString());
    if (params.page_size) queryParams.append('page_size', params.page_size.toString());
    if (params.ou_id) queryParams.append('ou_id', params.ou_id);
    if (params.is_leader !== undefined) queryParams.append('is_leader', params.is_leader.toString());
    if (params.status !== undefined) queryParams.append('status', params.status.toString());
    if (params.search) queryParams.append('search', params.search);

    const response = await get<UserListResponse>(
      `/admin/users/users?${queryParams.toString()}`
    );

    // console.log('用户列表API响应:', response);
    
    if (response.error) {
      console.error('获取用户列表失败:', response.error);
      return {
        success: false,
        error: response.error
      };
    }

    return {
      success: true,
      data: response.data
    };
  } catch (error) {
    console.error('获取用户列表失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取用户列表失败'
    };
  }
}

/**
 * 在组织架构树中查找指定节点并提取其用户
 * @param organizations 组织架构数据
 * @param targetOuId 目标节点的 ou_id
 * @returns 目标节点的用户列表转换为树节点
 */
export function extractUsersFromNode(organizations: OrganizationNode[], targetOuId: string): TreeNodeItem[] {
  // 递归查找目标节点
  function findNode(nodes: OrganizationNode[]): OrganizationNode | null {
    for (const node of nodes) {
      if (node.ou_id === targetOuId) {
        return node;
      }
      if (node.children && node.children.length > 0) {
        const found = findNode(node.children);
        if (found) return found;
      }
    }
    return null;
  }

  const targetNode = findNode(organizations);

  if (!targetNode) {
    console.warn('[extractUsersFromNode] 未找到目标节点:', targetOuId);
    return [];
  }

  // 将该节点的用户转换为树节点
  if (targetNode.users && targetNode.users.length > 0) {
    return targetNode.users.map(user => convertUserToTreeNode(user));
  }

  return [];
}

/**
 * 将组织架构数据转换为前端树形选择器格式
 * @param organizations 组织架构数据
 * @returns 前端树形选择器格式的数据
 */
export function convertToTreeData(organizations: OrganizationNode[]): TreeNodeItem[] {
  return organizations.map(org => {
    // 递归处理子组织
    const subOrganizations = org.children && org.children.length > 0 ? convertToTreeData(org.children) : [];
    // 添加该组织下的用户
    const userChildren = (org.users && org.users.length > 0)
      ? org.users.map(user => convertUserToTreeNode(user))
      : [];
    // 合并子组织和用户
    const children = [...subOrganizations, ...userChildren];

    // 判断是否已加载：
    // 1. 如果有子组织，说明数据已经完整（初始加载会返回完整的3层结构）
    // 2. 如果没有子组织但有用户，说明是叶子节点且用户已加载
    // 3. 如果既没有子组织也没有用户，说明是叶子节点但用户未加载（需要懒加载）
    const hasSubOrgs = org.children && org.children.length > 0;
    const hasUsers = org.users && org.users.length > 0;

    // hasChildren 为 true 的情况：
    // - 有子组织（可以展开查看下级）
    // - 没有用户且没有子组织（可能需要懒加载用户）
    const canExpand = hasSubOrgs || (!hasSubOrgs && !hasUsers);

    return {
      label: org.ou_name,
      value: org.ou_id,
      isUser: false,
      hasChildren: canExpand,
      isLoaded: hasSubOrgs || hasUsers,  // 有子组织或用户的节点视为已加载
      children: children.length > 0 ? children : undefined
    };
  });
}

/**
 * 将用户信息转换为树节点格式
 * @param user 用户信息
 * @returns 树节点
 */
export function convertUserToTreeNode(user: UserInfo): TreeNodeItem {
  return {
    label: user.nick_name,
    value: `user_${user.id}`,
    isUser: true,
    hasChildren: false,
    userInfo: user
  };
}

/**
 * 将搜索结果转换为树节点列表
 * @param users 用户列表
 * @returns 树节点列表
 */
export function convertSearchResultsToTreeNodes(users: UserInfo[]): TreeNodeItem[] {
  return users.map(user => convertUserToTreeNode(user));
}

// 树节点类型（用于 MultiCascader 组件）
export interface TreeNodeItem {
  label: string;
  value: string;
  isUser: boolean;
  hasChildren: boolean;
  userInfo?: UserInfo;
  children?: TreeNodeItem[];
}

/**
 * 获取扁平化组织列表
 * @param includeUsers 是否包含用户信息
 * @returns 扁平化组织列表
 */
export async function getFlatOrganizations(includeUsers: boolean = true): Promise<ApiResponse<OrganizationResponse>> {
  try {
    // console.log('开始调用获取扁平化组织列表API');
    
    const response = await get<OrganizationResponse>(
      `/admin/users/organizations/flat?include_users=${includeUsers}`
    );

    // console.log('扁平化组织列表API响应:', response);
    
    if (response.error) {
      console.error('获取扁平化组织列表失败:', response.error);
      return {
        success: false,
        error: response.error
      };
    }

    return {
      success: true,
      data: response.data
    };
  } catch (error) {
    console.error('获取扁平化组织列表失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取扁平化组织列表失败'
    };
  }
}