import type { VxeGridProps } from '#/adapter/vxe-table';
import type { FormSchemaGetter } from '#/adapter/form';

// 油站选项
export const stationOptions = [
  { label: '机场油站', value: '机场油站' },
  { label: '北京东加油站', value: '北京东加油站' },
  { label: '北京西加油站', value: '北京西加油站' },
  { label: '北京南加油站', value: '北京南加油站' },
  { label: '北京北加油站', value: '北京北加油站' },
  { label: '河北油站', value: '河北油站' },
  { label: '龙飞虎加油站', value: '龙飞虎加油站' },
  { label: '法站加油站', value: '法站加油站' },
];

// 油品号选项
export const oilTypeOptions = ['92#', '95#', '98#', '0#柴油', ' -10#柴油'];

// 出货油库选项
export const outflowDepotOptions = ['北京油库', '天津油库', '石家庄油库', '廊坊油库'];

// 进油损溢记录数据结构
export interface InflowLossRecordData {
  id: number;
  station: string; // 油站
  time: string; // 时间
  oilType: string; // 油品号
  outflowDepot: string; // 出货油库
  tankerNo: string; // 油罐车号码
  plannedQty: number; // 计划数量（A）
  actualDispatchQty: number; // 实发数量（B）
  outflowTemp: number; // 出库油温（C）
  arrivalTemp: number; // 到站油温（D）
  actualReceiveQty: number; // 实收数量（E）
  tempAdjustedQty: number; // 油站收油温度修正数量（F=B*(1+0.001*(D-C))）
  outflowLoss: number; // 油库发油损溢L（G=B-A）
  transportLoss: number; // 油车运输损溢L（H=E-F）
  stationDiff: number; // 油站进油差异L（I=E-A）
  outflowLossRate: number; // 油库发油损溢率‰（J=G/A*1000）
  transportLossRate: number; // 油车运输损溢率‰（K=H/B*1000）
  within8Loss: number; // 万分之八内损耗L（M）
  over8Loss: number; // 超万分之八内损耗L（M）
}

// 进油损溢统计数据结构
export interface InflowLossStatisticsData {
  id: number;
  station: string; // 油站
  oilType: string; // 油品
  plannedTotalQty: number; // 计划总量（L）
  actualDispatchTotalQty: number; // 实发总量（L）
  actualReceiveTotalQty: number; // 实收总量（L）
  tempAdjustedTotalQty: number; // 收油温度修正总量（L）
  outflowTotalLoss: number; // 发油损溢（L）
  transportTotalLoss: number; // 运输损溢（L）
  stationTotalDiff: number; // 进站差异（L）
  outflowTotalLossRate: number; // 发油损溢率（‰）
  transportTotalLossRate: number; // 运输损溢率（‰）
  within8TotalLoss: number; // 万分之八内损耗（L）
  over8TotalLoss: number; // 超万分之八内损耗（L）
}

// 进油损溢记录表格列配置
export const inflowLossRecordColumns: VxeGridProps['columns'] = [
  { title: '油站', field: 'station', minWidth: 120, align: 'center', fixed: 'left' },
  { title: '时间', field: 'time', minWidth: 160, align: 'center', fixed: 'left' },
  { title: '油品号', field: 'oilType', minWidth: 100, align: 'center' },
  { title: '出货油库', field: 'outflowDepot', minWidth: 120, align: 'center' },
  { title: '油罐车号码', field: 'tankerNo', minWidth: 140, align: 'center' },
  { 
    title: '计划数量', 
    children: [{ title: 'A', field: 'plannedQty', minWidth: 100, align: 'right' }] 
  },
  { 
    title: '实发数量', 
    children: [{ title: 'B', field: 'actualDispatchQty', minWidth: 100, align: 'right' }] 
  },
  { 
    title: '出库油温', 
    children: [{ title: 'C', field: 'outflowTemp', minWidth: 100, align: 'right' }] 
  },
  { 
    title: '到站油温', 
    children: [{ title: 'D', field: 'arrivalTemp', minWidth: 100, align: 'right' }] 
  },
  { 
    title: '实收数量', 
    children: [{ title: 'E', field: 'actualReceiveQty', minWidth: 100, align: 'right' }] 
  },
  { 
    title: '油站收油温度修正数量', 
    children: [{ title: 'F=B*(1+0.001*(D-C))', field: 'tempAdjustedQty', minWidth: 150, align: 'right' }] 
  },
  { 
    title: '油库发油损溢L', 
    children: [{ title: 'G=B-A', field: 'outflowLoss', minWidth: 120, align: 'right' }] 
  },
  { 
    title: '油车运输损溢L', 
    children: [{ title: 'H=E-F', field: 'transportLoss', minWidth: 120, align: 'right' }] 
  },
  { 
    title: '油站进油差异L', 
    children: [{ title: 'I=E-A', field: 'stationDiff', minWidth: 120, align: 'right' }] 
  },
  { 
    title: '油库发油损溢率‰', 
    children: [{ title: 'J=G/A*1000', field: 'outflowLossRate', minWidth: 120, align: 'right' }] 
  },
  { 
    title: '油车运输损溢率‰', 
    children: [{ title: 'K=H/B*1000', field: 'transportLossRate', minWidth: 120, align: 'right' }] 
  },
  { 
    title: '万分之八内损耗L', 
    children: [{ title: 'M', field: 'within8Loss', minWidth: 120, align: 'right' }] 
  },
  { 
    title: '超万分之八内损耗L', 
    children: [{ title: 'M', field: 'over8Loss', minWidth: 120, align: 'right' }] 
  },
];

// 进油损溢统计表格列配置
export const inflowLossStatisticsColumns: VxeGridProps['columns'] = [
  { title: '油站', field: 'station', minWidth: 120, align: 'center', fixed: 'left' },
  { title: '油品', field: 'oilType', minWidth: 100, align: 'center' },
  { title: '计划总量（L）', field: 'plannedTotalQty', minWidth: 120, align: 'right' },
  { title: '实发总量（L）', field: 'actualDispatchTotalQty', minWidth: 120, align: 'right' },
  { title: '实收总量（L）', field: 'actualReceiveTotalQty', minWidth: 120, align: 'right' },
  { title: '收油温度修正总量（L）', field: 'tempAdjustedTotalQty', minWidth: 150, align: 'right' },
  { title: '发油损溢（L）', field: 'outflowTotalLoss', minWidth: 120, align: 'right' },
  { title: '运输损溢（L）', field: 'transportTotalLoss', minWidth: 120, align: 'right' },
  { title: '进站差异（L）', field: 'stationTotalDiff', minWidth: 120, align: 'right' },
  { title: '发油损溢率（‰）', field: 'outflowTotalLossRate', minWidth: 120, align: 'right' },
  { title: '运输损溢率（‰）', field: 'transportTotalLossRate', minWidth: 120, align: 'right' },
  { title: '万分之八内损耗（L）', field: 'within8TotalLoss', minWidth: 120, align: 'right' },
  { title: '超万分之八内损耗（L）', field: 'over8TotalLoss', minWidth: 120, align: 'right' },
];

// 通用搜索表单配置
export const commonQuerySchema: FormSchemaGetter = () => [
  {
    component: 'Select',
    fieldName: 'station',
    label: '油站',
    componentProps: {
      placeholder: '请选择油站',
      options: stationOptions,
    },
  },
  {
    component: 'DatePicker',
    fieldName: 'timeRange',
    label: '时间',
    componentProps: {
      type: 'daterange',
      placeholder: ['开始时间', '结束时间'],
    },
  },
];

// 进油损溢记录搜索表单配置
export const inflowLossRecordQuerySchema: FormSchemaGetter = commonQuerySchema;

// 进油损溢统计搜索表单配置
export const inflowLossStatisticsQuerySchema: FormSchemaGetter = commonQuerySchema;

// 生成随机油罐车号码
const generateTankerNo = (): string => {
  const prefixes = ['京A', '京B', '津A', '冀A', '冀B'];
  const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
  const numbers = Math.floor(Math.random() * 9000) + 1000;
  return `${prefix}·${numbers}`;
};

// 生成随机时间（过去30天内）
const generateRandomTime = (): string => {
  const now = new Date();
  const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
  const randomTime = new Date(thirtyDaysAgo.getTime() + Math.random() * (now.getTime() - thirtyDaysAgo.getTime()));
  return randomTime.toISOString().split('T')[0];
};

// 生成进油损溢记录模拟数据
export const generateInflowLossRecordData = (): InflowLossRecordData[] => {
  return Array.from({ length: 50 }, (_, i) => {
    const station = stationOptions[Math.floor(Math.random() * stationOptions.length)].value;
    const oilType = oilTypeOptions[Math.floor(Math.random() * oilTypeOptions.length)];
    const outflowDepot = outflowDepotOptions[Math.floor(Math.random() * outflowDepotOptions.length)];
    const tankerNo = generateTankerNo();
    const time = generateRandomTime();
    
    // 基础数据
    const plannedQty = parseFloat((Math.random() * 1000 + 500).toFixed(2)); // 计划数量（A）
    const actualDispatchQty = parseFloat((plannedQty + Math.random() * 50 - 25).toFixed(2)); // 实发数量（B）
    const outflowTemp = parseFloat((Math.random() * 10 + 20).toFixed(2)); // 出库油温（C）
    const arrivalTemp = parseFloat((outflowTemp + Math.random() * 5 - 2.5).toFixed(2)); // 到站油温（D）
    const actualReceiveQty = parseFloat((actualDispatchQty + Math.random() * 30 - 15).toFixed(2)); // 实收数量（E）
    
    // 计算字段
    const tempAdjustedQty = parseFloat((actualDispatchQty * (1 + 0.001 * (arrivalTemp - outflowTemp))).toFixed(2)); // 温度修正数量（F）
    const outflowLoss = parseFloat((actualDispatchQty - plannedQty).toFixed(2)); // 油库发油损溢L（G）
    const transportLoss = parseFloat((actualReceiveQty - tempAdjustedQty).toFixed(2)); // 油车运输损溢L（H）
    const stationDiff = parseFloat((actualReceiveQty - plannedQty).toFixed(2)); // 油站进油差异L（I）
    const outflowLossRate = parseFloat(((outflowLoss / plannedQty) * 1000).toFixed(2)); // 油库发油损溢率‰（J）
    const transportLossRate = parseFloat(((transportLoss / actualDispatchQty) * 1000).toFixed(2)); // 油车运输损溢率‰（K）
    
    // 万分之八损耗计算
    const eightPerMillion = plannedQty * 0.0008;
    const within8Loss = Math.min(Math.abs(stationDiff), eightPerMillion);
    const over8Loss = Math.max(0, Math.abs(stationDiff) - eightPerMillion);
    
    return {
      id: i + 1,
      station,
      time,
      oilType,
      outflowDepot,
      tankerNo,
      plannedQty,
      actualDispatchQty,
      outflowTemp,
      arrivalTemp,
      actualReceiveQty,
      tempAdjustedQty,
      outflowLoss,
      transportLoss,
      stationDiff,
      outflowLossRate,
      transportLossRate,
      within8Loss: parseFloat(within8Loss.toFixed(2)),
      over8Loss: parseFloat(over8Loss.toFixed(2)),
    };
  });
};

// 生成进油损溢统计模拟数据
export const generateInflowLossStatisticsData = (): InflowLossStatisticsData[] => {
  const recordData = generateInflowLossRecordData();
  const statisticsMap = new Map<string, InflowLossStatisticsData>();
  
  // 按油站和油品分组统计
  recordData.forEach(record => {
    const key = `${record.station}-${record.oilType}`;
    if (!statisticsMap.has(key)) {
      statisticsMap.set(key, {
        id: statisticsMap.size + 1,
        station: record.station,
        oilType: record.oilType,
        plannedTotalQty: 0,
        actualDispatchTotalQty: 0,
        actualReceiveTotalQty: 0,
        tempAdjustedTotalQty: 0,
        outflowTotalLoss: 0,
        transportTotalLoss: 0,
        stationTotalDiff: 0,
        outflowTotalLossRate: 0,
        transportTotalLossRate: 0,
        within8TotalLoss: 0,
        over8TotalLoss: 0,
      });
    }
    
    const stats = statisticsMap.get(key)!;
    stats.plannedTotalQty += record.plannedQty;
    stats.actualDispatchTotalQty += record.actualDispatchQty;
    stats.actualReceiveTotalQty += record.actualReceiveQty;
    stats.tempAdjustedTotalQty += record.tempAdjustedQty;
    stats.outflowTotalLoss += record.outflowLoss;
    stats.transportTotalLoss += record.transportLoss;
    stats.stationTotalDiff += record.stationDiff;
    stats.within8TotalLoss += record.within8Loss;
    stats.over8TotalLoss += record.over8Loss;
  });
  
  // 计算损溢率
  return Array.from(statisticsMap.values()).map(stats => {
    stats.plannedTotalQty = parseFloat(stats.plannedTotalQty.toFixed(2));
    stats.actualDispatchTotalQty = parseFloat(stats.actualDispatchTotalQty.toFixed(2));
    stats.actualReceiveTotalQty = parseFloat(stats.actualReceiveTotalQty.toFixed(2));
    stats.tempAdjustedTotalQty = parseFloat(stats.tempAdjustedTotalQty.toFixed(2));
    stats.outflowTotalLoss = parseFloat(stats.outflowTotalLoss.toFixed(2));
    stats.transportTotalLoss = parseFloat(stats.transportTotalLoss.toFixed(2));
    stats.stationTotalDiff = parseFloat(stats.stationTotalDiff.toFixed(2));
    stats.within8TotalLoss = parseFloat(stats.within8TotalLoss.toFixed(2));
    stats.over8TotalLoss = parseFloat(stats.over8TotalLoss.toFixed(2));
    
    stats.outflowTotalLossRate = stats.plannedTotalQty > 0 
      ? parseFloat(((stats.outflowTotalLoss / stats.plannedTotalQty) * 1000).toFixed(2)) 
      : 0;
    stats.transportTotalLossRate = stats.actualDispatchTotalQty > 0 
      ? parseFloat(((stats.transportTotalLoss / stats.actualDispatchTotalQty) * 1000).toFixed(2)) 
      : 0;
    
    return stats;
  });
};

// 导出模拟数据
export const mockInflowLossRecordData = generateInflowLossRecordData();
export const mockInflowLossStatisticsData = generateInflowLossStatisticsData();
