import axios from 'axios';
import * as THREE from 'three';
import { 
  AlarmDeviceData,
  CategoryChartData,
  CategoryChartDataWithPercent,
  OnlineRateChartData,
  StateChartData,
  StateChartDataWithPercent,
  AlarmChartData,
  DeviceWithAssetInfo,
} from '../share/monitorTypes.ts';


// API请求参数类型定义
interface OnlineRateChartParams {
  created_at?: {
    $gte: string;
    $lte: string;
  };
  dimension?: {
    $eq: 'hour' | 'day' | 'month';
  };
  pagination?: {
    page: number;
    pageSize: number;
  };
}

interface AlarmChartParams {
  created_at?: {
    $gte: string;
    $lte: string;
  };
  dimension?: {
    $eq: 'hour' | 'day' | 'month';
  };
}

interface DeviceInstancesParams {
  is_deleted?: number;
}

interface RackQueryParams {
  is_deleted?: number;
}

interface RackServerQueryParams {
  rack_id?: number;
  is_deleted?: number;
}

interface RackServerTypeParams {
  is_enabled?: number;
  is_deleted?: number;
  page?: number;
  pageSize?: number;
}

// 机柜数据
interface RackData {
  id: number;
  rack_name: string;
  rack_code: string;
  capacity: number;
  position_x: number;
  position_y: number;
  position_z: number;
  area?: string;
  room?: string;
  remark?: string;
  is_disabled: number;
  is_deleted: number;
  created_at: string;
  updated_at: string;
}

// 机柜服务器数据
interface RackServerData {
  id: number;
  rack_id: number;
  asset_id: number;
  start_position: number;
  size: number;
  server_type?: string;
  remark?: string;
  is_disabled: number;
  is_deleted: number;
  created_at: string;
  updated_at: string;
  // 关联字段 asset
  asset_name: string;
  device_category: number;
  ip_address?: string;
  device_status: number;
  network_status: number;
  packet_loss: number;
  cpu?: string;
  memory?: string;
  disk?: string;
  // 关联字段 rack
  rack_name: string;
  rack_code: string;
}

// 设备类型图标数据
interface DeviceIconData {
  id: number;
  category_id: number;
  icon: string;
  icon_name?: string;
  icon_type: string;
  sort: number;
  is_default: number;
  is_disabled: number;
  is_deleted: number;
  created_at: string;
  updated_at: string;
  category?: {
    name: string;
  };
}

// 机柜服务器类型数据
interface RackServerType {
  /** 主键ID */
  id: number;
  
  /** 类型名称 */
  name: string;
  
  /** 类型编码 */
  code: string;

  /** 类型图片 */
  image_url?: string;
  
  /** 类型描述 */
  description?: string;
  
  /** 是否启用 (0否 1是) */
  is_enabled?: number;
  
  /** 是否被删除 (0否 1是) */
  is_deleted?: number;
  
  /** 创建时间 */
  created_at: string;
  
  /** 更新时间 */
  updated_at: string;
}

// 服务器基本信息接口
export interface ServerData {
  id: number;
  slot: number;
  u: number;
  type: number;
  name: string;
  ip: string;
  cpu: string;
  memory: string;
  disk: string;
  deviceStatus: number;
  networkStatus: number;
  packetLoss: number;
}

// 设备状态和监控数据接口
export interface DeviceStatusInfo {
  status: 'online' | 'offline' | 'warning';
  usage: {
    cpu: number;
    memory: number;
    disk: number;
  };
}

// 机柜配置接口
export interface RackConfig {
  position: THREE.Vector3;
  serverCount: number;
  id: number;
  name: string;
  servers: ServerData[];
}

// 服务器图标接口
export interface ServerIconConfig {
  textureUrl: string | null;
  color: number;
}

export interface ServerIconConfigs {
  [key: number]: ServerIconConfig;
} 




const API_BASE_URL = '/api';
// 从全局配置中获取OSS_HOST，如果不存在则使用默认值
const OSS_BASE_URL = window.CONFIG?.OSS_BASE_URL || '';


// 计算风险等级
const calculateRiskLevel = (onlineRate: number): { level: string; color: string } => {
  if (onlineRate >= 95) {
    return { level: '健康', color: '#52c41a' }; // 绿色
  } else if (onlineRate >= 80) {
    return { level: '风险低', color: '#faad14' }; // 黄色
  } else if (onlineRate >= 70) {
    return { level: '风险中', color: '#faad14' }; // 黄色
  } else {
    return { level: '高风险', color: '#f5222d' }; // 红色
  }
};

// 统一将查询函数提取到顶部
export const queryFns = {
  // 资产分类数据查询
  fetchCategoryData: async (): Promise<CategoryChartDataWithPercent[]> => {
    const res = await axios.get<CategoryChartData[]>(`${API_BASE_URL}/big/zichan_category_chart`);
    
    // 预先计算百分比
    const data = res.data;
    const total = data.reduce((sum: number, item: CategoryChartData) => sum + item['设备数'], 0);
    
    // 为每个数据项添加百分比字段
    return data.map(item => ({
      ...item,
      百分比: total > 0 ? (item['设备数'] / total * 100).toFixed(1) : '0'
    }));
  },

  // 在线率变化数据查询
  fetchOnlineRateData: async (): Promise<OnlineRateChartData[]> => {
    // 直接使用扁平化参数
    const params = {
      // created_at_gte: dayjs().subtract(7, 'day').format('YYYY-MM-DD HH:mm:ss'),
      // created_at_lte: dayjs().format('YYYY-MM-DD HH:mm:ss'),
      // dimension: 'day',
      // page: 1,
      // pageSize: 1000
    };
    
    const res = await axios.get<OnlineRateChartData[]>(`${API_BASE_URL}/big/zichan_online_rate_chart`, { params });
    return res.data;
  },

  // 资产流转状态数据查询
  fetchStateData: async (): Promise<StateChartDataWithPercent[]> => {
    const res = await axios.get<StateChartData[]>(`${API_BASE_URL}/big/zichan_state_chart`);
    
    // 预先计算百分比
    const data = res.data;
    const total = data.reduce((sum: number, item: StateChartData) => sum + item['设备数'], 0);
    
    // 为每个数据项添加百分比字段
    return data.map(item => ({
      ...item,
      百分比: total > 0 ? (item['设备数'] / total * 100).toFixed(1) : '0'
    }));
  },

  // 告警数据变化查询
  fetchAlarmData: async (): Promise<AlarmChartData[]> => {
    // 直接使用扁平化参数
    const params = {
      // created_at_gte: dayjs().startOf('day').format('YYYY-MM-DD HH:mm:ss'),
      // created_at_lte: dayjs().endOf('day').format('YYYY-MM-DD HH:mm:ss'),
      // dimension: 'hour'
    };
    
    const res = await axios.get<AlarmChartData[]>(`${API_BASE_URL}/big/zichan_alarm_chart`, { params });
    return res.data;
  },

  // 获取设备数据
  fetchDeviceMetrics: async () => {
    const params = { 
      is_deleted: 0
    };
    const response = await axios.get<DeviceWithAssetInfo[]>(`${API_BASE_URL}/big/device-instances`, { params });

    const devices = response.data;
    const totalDevices = devices.length;
    const onlineDevices = devices.filter(device => device.device_status === 1).length;
    const offlineDevices = totalDevices - onlineDevices;
    const onlineRate = totalDevices ? ((onlineDevices / totalDevices) * 100) : 0;
    const riskLevel = calculateRiskLevel(onlineRate);

    return {
      totalDevices,
      onlineDevices,
      offlineDevices,
      onlineRate: onlineRate.toFixed(2),
      riskLevel
    };
  },

  // 获取告警设备数据
  fetchTopAlarmDevices: async (): Promise<AlarmDeviceData[]> => {
    const response = await axios.get<AlarmDeviceData[]>(`${API_BASE_URL}/big/zichan_alarm_device`);
    return response.data;
  },

  // 获取机柜配置数据
  fetchRackConfigs: async (): Promise<RackConfig[]> => {
    const params: RackQueryParams = {
      is_deleted: 0
    }
    // 1. 获取机柜数据
    const rackResponse = await axios.get<RackData[]>(`${API_BASE_URL}/big/rack`, { params });

    const racks = rackResponse.data;
    
    // 2. 获取所有机柜的服务器数据
    const serverPromises = racks.map(async (rack: RackData) => {
      const params: RackServerQueryParams = { 
        rack_id: rack.id,
        is_deleted: 0
      }
      const serverResponse = await axios.get<RackServerData[]>(`${API_BASE_URL}/big/rack-server`, { params });

      // 3. 获取每个服务器对应的基本信息
      let servers: ServerData[] = [];
      try {
        servers = serverResponse.data.map((server: RackServerData) => ({
          id: server.id,
          slot: server.start_position,
          u: server.size,
          type: server.device_category,
          name: server.asset_name || '',
          ip: server.ip_address || '',
          cpu: server.cpu || '',
          memory: server.memory || '',
          disk: server.disk || '',
          deviceStatus: server.device_status || 0,
          networkStatus: server.network_status || 0,
          packetLoss: server.packet_loss || 0
        }));
      } catch (error) {
        console.error("error", error);
      }

      // 返回包含服务器数据的机柜配置
      return {
        position: new THREE.Vector3(Number(rack.position_x) || 0, Number(rack.position_y) || 0, Number(rack.position_z) || 0),
        serverCount: rack.capacity || 42,
        id: rack.id,
        name: rack.rack_name,
        servers
      };
    });

    // 等待所有数据获取完成
    return Promise.all(serverPromises);
  },

  // 获取服务器类型图标配置
  fetchDeviceIcons: async (): Promise<ServerIconConfigs> => {
    const params: RackServerTypeParams = {
      is_enabled: 1,
      is_deleted: 0,
      page: 1,
      pageSize: 100
    }
    const response = await axios.get<RackServerType[]>(`${API_BASE_URL}/big/rack/server/type/image`, { params });

    const ossHost = OSS_BASE_URL;
    return response.data.reduce((acc: ServerIconConfigs, type: RackServerType) => {
      acc[type.id] = {
        textureUrl: type.image_url ? `${ossHost}/${type.image_url}` : null,
        color: 0x444444
      };
      return acc;
    }, {});
  }
}