import { Hono } from 'hono';
import type {
  Vehicle,
  SummaryData,
  TypeSummary,
  ModelSummary,
  BatchSummary,
  BatchGroup,
  InventoryTypeSummary,
} from '../types.js';
import { filterByPermission, maskCustomerNames, maskCustomerName } from '../auth/permissions.js';
import type { AuthUser } from '../auth/types.js';
import type { Context } from 'hono';
import {
  INVENTORY_REGIONS,
  SUMMARY_TYPE_FILTERS,
  VEHICLE_TYPE_FILTERS,
  classifyVehicleType,
  compareModelNames,
  filterByLocation,
  mapInventoryRegion,
  mapMacroRegion,
  resolveCity,
} from './vehicles/model.js';
import {
  compareDepartmentNames,
  countByType,
  getMileageStats,
  getStats,
  listDateRange,
  normalizeDateRange,
} from './vehicles/utils.js';
import { vehicleRepository, type FlowDetailRow, type WeeklyDetailType } from './vehicles/repository.js';

export { mapRegion } from './vehicles/model.js';

const app = new Hono();

async function getVehiclesForUser(c: Context): Promise<Vehicle[]> {
  const all = await vehicleRepository.getVehicles();
  const user = ((c as any).get?.('user') || (c as any).var?.user) as AuthUser | undefined;
  let list = user ? filterByPermission(all, user) : all;
  list = applySubjectFilter(c, list);
  return maskCustomerNames(list);
}

// 归属公司筛选（所属公司 = vehicle_info.registered_ownership, 即 Vehicle.subjectOrg）
function getSubjectParam(c: Context): string | null {
  const raw = (c.req.query('subject') || '').trim();
  return raw ? raw : null;
}

function applySubjectFilter(c: Context, vehicles: Vehicle[]): Vehicle[] {
  const subject = getSubjectParam(c);
  if (!subject) return vehicles;
  return vehicles.filter((v) => (v.subjectOrg || '') === subject);
}

// GET /api/vehicles/summary
app.get('/summary', async (c) => {
  const [vehicles, weeklyIds] = await Promise.all([getVehiclesForUser(c), vehicleRepository.getWeeklyTruckIds()]);
  const vehicleIds = new Set(vehicles.map(v => String(v.id)));
  const summary: SummaryData = {
    totalAssets: vehicles.length,
	    operating: {
	      total: vehicles.filter((v) => v.status === 'Operating' && (v.operationStatus === '1' || v.operationStatus === '2')).length,
	      self: vehicles.filter((v) => v.status === 'Operating' && v.operationStatus === '2').length,
	      leased: vehicles.filter((v) => v.status === 'Operating' && v.operationStatus === '1').length,
	      public: vehicles.filter((v) => v.status === 'Operating' && v.ownership === 'Public').length,
	      hanging: 0,
	    },
    inventory: {
      total: vehicles.filter((v) => v.status === 'Inventory' || v.status === 'Abnormal').length,
      inStock: vehicles.filter((v) => v.status === 'Inventory').length,
      abnormal: vehicles.filter((v) => v.status === 'Abnormal').length,
    },
    pendingDelivery: vehicles.filter((v) => v.status === 'Pending').length,
    weeklyNew: 0,
    weeklyRemoved: 0,
    weeklyDelivered: [...weeklyIds.delivered].filter(id => vehicleIds.has(id)).length,
    weeklyReturned: [...weeklyIds.returned].filter(id => vehicleIds.has(id)).length,
    weeklyReplaced: [...weeklyIds.replaced].filter(id => vehicleIds.has(id)).length,
  };
  return c.json(summary);
});

// GET /api/vehicles/by-type
app.get('/by-type', async (c) => {
  const [vehicles, weeklyIds] = await Promise.all([getVehiclesForUser(c), vehicleRepository.getWeeklyTruckIds()]);

  const result: TypeSummary[] = SUMMARY_TYPE_FILTERS.map((t) => {
    const typeVehicles = vehicles.filter(t.filter);
    const models = Array.from(new Set(typeVehicles.map((v) => v.model)));

    const modelSummaries: ModelSummary[] = models.map((model) => {
      const modelVehicles = typeVehicles.filter((v) => v.model === model);
      const batches = Array.from(new Set(modelVehicles.map((v) => v.contractNo || '未知'))).filter(Boolean);

      return {
        model,
        ...getStats(modelVehicles, weeklyIds),
        batches: batches.map((batch) => ({
          batch,
          ...getStats(modelVehicles.filter((v) => (v.contractNo || '未知') === batch), weeklyIds),
        })),
      };
    });

    const typeStats = getStats(typeVehicles, weeklyIds);
    return {
      type: t.name,
      totalAssets: typeVehicles.length,
      totalInventory: typeStats.inventory,
      totalOperating: typeStats.operating,
      inventoryRegions: typeStats.inventoryRegions,
      pending: typeStats.pending,
      weeklyDelivered: typeStats.weeklyDelivered,
      weeklyReturned: typeStats.weeklyReturned,
      weeklyReplaced: typeStats.weeklyReplaced,
      models: modelSummaries.sort((a, b) => compareModelNames(a.model, b.model)),
    };
  });

  return c.json(result);
});

// GET /api/vehicles/by-batch
app.get('/by-batch', async (c) => {
  const vehicles = await getVehiclesForUser(c);
  const batches = Array.from(new Set(vehicles.map((v) => v.contractNo || '未知')))
    .filter(Boolean)
    .sort()
    .reverse();

  const result: BatchGroup[] = batches.map((batch) => {
    const batchVehicles = vehicles.filter((v) => (v.contractNo || '未知') === batch);
    const models = Array.from(new Set(batchVehicles.map((v) => v.model)));

    return {
      batch,
      ...getStats(batchVehicles),
      models: models.map((model) => {
        const modelVehicles = batchVehicles.filter((v) => v.model === model);
        return {
          model,
          type: modelVehicles[0]?.type || '',
          ...getStats(modelVehicles),
        };
      }),
    };
  });

  return c.json(result);
});

// GET /api/vehicles/inventory-analysis — 库存分析，不设数据权限，对所有人开放
app.get('/inventory-analysis', async (c) => {
  const vehicles = applySubjectFilter(c, await vehicleRepository.getVehicles());

  const result: InventoryTypeSummary[] = SUMMARY_TYPE_FILTERS.map((t) => {
    const typeVehicles = vehicles.filter(t.filter);
    const models = Array.from(new Set(typeVehicles.map((v) => v.model)));

    const modelData = models.map((model) => {
      const modelVehicles = typeVehicles.filter((v) => v.model === model);
      const inventoryVehicles = modelVehicles.filter((v) => v.status === 'Inventory');

      return {
        model,
        totalAssets: modelVehicles.length,
        totalInventory: inventoryVehicles.length,
        regions: INVENTORY_REGIONS.reduce(
          (acc, reg) => {
            acc[reg] = inventoryVehicles.filter((v) => mapInventoryRegion(v.location) === reg).length;
            return acc;
          },
          {} as Record<string, number>,
        ),
      };
    });

    const typeInventory = typeVehicles.filter((v) => v.status === 'Inventory');

    return {
      type: t.name,
      totalAssets: typeVehicles.length,
      totalInventory: typeInventory.length,
      models: modelData,
      regionSubtotals: INVENTORY_REGIONS.reduce(
        (acc, reg) => {
          acc[reg] = typeInventory.filter((v) => mapInventoryRegion(v.location) === reg).length;
          return acc;
        },
        {} as Record<string, number>,
      ),
    };
  });

  return c.json(result);
});

// GET /api/vehicles/dept-stats — department & manager breakdown with mileage/attendance
app.get('/dept-stats', async (c) => {
  const vehicles = await getVehiclesForUser(c);
  const withManager = vehicles.filter((v) => v.status === 'Operating');

  // Query realtime day_mileage from tab_truck_remote_sync_realtime_info
  const realtimeRows = await vehicleRepository.getRealtimeMileageRows();
  const todayMileageMap = new Map<string, number>();
  for (const row of realtimeRows as any[]) {
    const plate = (row.plate_number || '').trim();
    if (plate) todayMileageMap.set(plate, Number(row.day_mileage) || 0);
  }

  // 不在部门列表展示的用户（非业务员或管理账号）
  const EXCLUDED_MANAGERS = new Set(['超级用户', '刘思宇', '潘舒', '黄卓华', '许铮杰']);

  const deptMap = new Map<string, Map<string, Vehicle[]>>();
  for (const v of withManager) {
    const isPublicServiceVehicle = v.model === '公务车/挂靠车';
    const dept = isPublicServiceVehicle ? '公务车' : (v.departmentName || '未分配部门');
    const mgr = v.customerManager || '未分配';
    if (EXCLUDED_MANAGERS.has(mgr)) continue;
    if (!deptMap.has(dept)) deptMap.set(dept, new Map());
    const mgrMap = deptMap.get(dept)!;
    if (!mgrMap.has(mgr)) mgrMap.set(mgr, []);
    mgrMap.get(mgr)!.push(v);
  }

  const result = Array.from(deptMap.entries()).map(([department, mgrMap]) => {
    const allDeptVehicles = Array.from(mgrMap.values()).flat();
    const deptMileage = getMileageStats(allDeptVehicles, todayMileageMap);
    const managers = Array.from(mgrMap.entries())
      .map(([manager, mvs]) => ({ manager, department, ...countByType(mvs) }))
      .sort((a, b) => b.total - a.total);
    return {
      department,
      totalAssets: allDeptVehicles.length,
      operatingCount: allDeptVehicles.filter((v) => (todayMileageMap.get(v.plateNumber) || 0) > 0).length,
      idleCount: allDeptVehicles.filter((v) => (todayMileageMap.get(v.plateNumber) || 0) === 0).length,
      attendanceRate: deptMileage.attendanceRate,
      avgMileage: deptMileage.avgMileage,
      managers,
    };
  }).sort((a, b) => compareDepartmentNames(a.department, b.department));

  return c.json(result);
});

// GET /api/vehicles/region-stats — macro-region with city drill-down
app.get('/region-stats', async (c) => {
  const vehicles = await getVehiclesForUser(c);
  const { customer, city: filterCity, region: filterRegion } = c.req.query();
  let operating = vehicles.filter((v) => v.status === 'Operating' || v.status === 'Pending');
  if (customer) operating = operating.filter((v) => v.customerName === customer);
  if (filterCity) operating = operating.filter((v) => resolveCity(v.city, v.province) === filterCity);
  if (filterRegion) operating = operating.filter((v) => mapMacroRegion(v.province, v.city) === filterRegion);

  const regionCityMap = new Map<string, Map<string, Vehicle[]>>();
  for (const v of operating) {
    const region = mapMacroRegion(v.province, v.city);
    const city = resolveCity(v.city, v.province);
    if (!regionCityMap.has(region)) regionCityMap.set(region, new Map());
    const cityMap = regionCityMap.get(region)!;
    if (!cityMap.has(city)) cityMap.set(city, []);
    cityMap.get(city)!.push(v);
  }

  const getTypeBreakdown = (vList: Vehicle[]) => {
    const KNOWN = ['4.5T', '18T', '49T'] as const;
    const make = (label: string, tv: Vehicle[]) => ({
      type: label,
      total: tv.length,
      operating: tv.filter((v) => v.status === 'Operating').length,
      inventory: tv.filter((v) => v.status === 'Inventory').length,
      pending: tv.filter((v) => v.status === 'Pending').length,
      customers: Array.from(new Set(tv.map((v) => v.customerName).filter(Boolean))) as string[],
    });
    const known = KNOWN.map((type) => make(type, vList.filter((v) => v.type === type)));
    const other = vList.filter((v) => !KNOWN.includes(v.type as typeof KNOWN[number]));
    if (other.length > 0) known.push(make('其他', other));
    return known.filter((t) => t.total > 0);
  };

  const regionOrder = ['华东', '华南', '华北', '华中', '西南', '西北', '其他'];
  const result = regionOrder
    .filter((r) => regionCityMap.has(r))
    .map((region) => {
      const cityMap = regionCityMap.get(region)!;
      const allVehicles = Array.from(cityMap.values()).flat();
      const customers = Array.from(new Set(allVehicles.map((v) => v.customerName).filter(Boolean))) as string[];
      const allCities = Array.from(cityMap.entries())
        .map(([city, cv]) => ({
          city,
          totalAssets: cv.length,
          operatingCount: cv.filter((v) => v.status === 'Operating').length,
          pendingCount: cv.filter((v) => v.status === 'Pending').length,
          customers: Array.from(new Set(cv.map((v) => v.customerName).filter(Boolean))) as string[],
          typeBreakdown: getTypeBreakdown(cv),
        }))
        .sort((a, b) => b.totalAssets - a.totalAssets);

      // Top 8 cities + merge rest into "其他"
      const topCities = allCities.slice(0, 8);
      const restCities = allCities.slice(8);
      if (restCities.length > 0) {
        const restVehicles = restCities.flatMap((c) => {
          const key = c.city;
          return cityMap.get(key) || [];
        });
        topCities.push({
          city: '其他',
          totalAssets: restCities.reduce((s, c) => s + c.totalAssets, 0),
          operatingCount: restCities.reduce((s, c) => s + c.operatingCount, 0),
          pendingCount: restCities.reduce((s, c) => s + (c.pendingCount || 0), 0),
          customers: Array.from(new Set(restVehicles.map((v) => v.customerName).filter(Boolean))) as string[],
          typeBreakdown: getTypeBreakdown(restVehicles),
        });
      }
      const cities = topCities;

      return {
        region,
        totalAssets: allVehicles.length,
        operatingCount: allVehicles.filter((v) => v.status === 'Operating').length,
        pendingCount: allVehicles.filter((v) => v.status === 'Pending').length,
        customers,
        typeBreakdown: getTypeBreakdown(allVehicles),
        cities,
      };
    });

  return c.json(result);
});

// GET /api/vehicles/customer-stats — per-customer breakdown for operating vehicles
app.get('/customer-stats', async (c) => {
  const vehicles = await getVehiclesForUser(c);
  const operating = vehicles.filter((v) => v.status === 'Operating');

  const custMap = new Map<string, Vehicle[]>();
  for (const v of operating) {
    const cust = v.customerName || '未分配客户';
    if (!custMap.has(cust)) custMap.set(cust, []);
    custMap.get(cust)!.push(v);
  }

  const result = Array.from(custMap.entries())
    .map(([customer, cvs]) => {
      const first = cvs[0];
      return {
        customer,
        manager: first.customerManager || '',
        brand: first.brandLabel || '',
        department: first.departmentName || '',
        region: mapMacroRegion(first.province, first.city),
        city: first.city || '',
        ...countByType(cvs),
      };
    })
    .sort((a, b) => b.total - a.total);

  return c.json(result);
});

// GET /api/vehicles/list — flat list with optional filters
app.get('/list', async (c) => {
  const vehicles = await getVehiclesForUser(c);
  const { batch, model, location, status, category, vehicleType, manager, customer, isColdChain, isTrailer, department, attendance } = c.req.query();

  let filtered = vehicles;

  // attendance filter: active = day_mileage > 0, idle = day_mileage = 0 (only for Operating vehicles)
  if (attendance === 'active' || attendance === 'idle') {
    const realtimeRows = await vehicleRepository.getAttendanceMileageRows();
    const todayMap = new Map<string, number>();
    for (const row of realtimeRows as any[]) todayMap.set((row.plate_number || '').trim(), Number(row.day_mileage) || 0);
    filtered = filtered.filter((v) => v.status === 'Operating');
    if (attendance === 'active') {
      filtered = filtered.filter((v) => (todayMap.get(v.plateNumber) || 0) > 0);
    } else {
      filtered = filtered.filter((v) => (todayMap.get(v.plateNumber) || 0) === 0);
    }
  }
  if (vehicleType) {
    if (VEHICLE_TYPE_FILTERS[vehicleType]) {
      filtered = filtered.filter(VEHICLE_TYPE_FILTERS[vehicleType]);
    } else if (vehicleType === '4.5T') {
      filtered = filtered.filter((v) => v.type === '4.5T');
    } else {
      filtered = filtered.filter((v) => v.type === vehicleType);
    }
  }
  if (batch && batch !== 'All') {
    filtered = filtered.filter((v) => (v.contractNo || '未知') === batch);
  }
  if (model && model !== 'All') {
    filtered = filtered.filter((v) => v.model === model);
  }
  if (location && location !== 'All') {
    filtered = filterByLocation(filtered, location, c.req.query('source'));
  }
  if (status && status !== 'All') {
    filtered = filtered.filter((v) => v.status === status);
  }
  if (category) {
    if (category === 'Inventory') {
      filtered = filtered.filter((v) => v.status === 'Inventory' || v.status === 'Abnormal');
    } else if (category === 'Operating') {
      filtered = filtered.filter((v) => v.status === 'Operating');
    } else if (category === 'Pending') {
      filtered = filtered.filter((v) => v.status === 'Pending');
    }
  }
  if (manager) {
    filtered = filtered.filter((v) => manager === '未分配' ? !v.customerManager : v.customerManager === manager);
  }
  if (customer) {
    filtered = filtered.filter((v) => customer === '未分配客户' ? !v.customerName : v.customerName === customer);
  }
  if (department) {
    filtered = filtered.filter((v) => {
      if (department === '公务车') return v.model === '公务车/挂靠车';
      if (department === '未分配部门') return v.model !== '公务车/挂靠车' && !v.departmentName;
      return v.departmentName === department;
    });
  }
  if (isColdChain !== undefined) {
    const wantCold = isColdChain === 'true';
    filtered = filtered.filter((v) => wantCold ? v.model.includes('冷链') : !v.model.includes('冷链'));
  }
  if (isTrailer !== undefined) {
    const wantTrailer = isTrailer === 'true';
    filtered = filtered.filter((v) => wantTrailer ? (v.type === '挂车' || v.model.includes('挂车')) : !(v.type === '挂车' || v.model.includes('挂车')));
  }

  return c.json(
    filtered.map((v) => ({
      id: v.id,
      plateNumber: v.plateNumber,
      vin: v.vin,
      type: v.type,
      model: v.model,
      location: v.location,
      province: v.province,
      city: v.city,
	      status: v.status,
	      ownership: v.ownership,
	      rentCompany: v.rentCompany,
	      contractNo: v.contractNo,
      customerName: v.customerName,
      subjectOrg: v.subjectOrg,
      departmentName: v.departmentName,
      customerManager: v.customerManager,
      brandLabel: v.brandLabel,
      orgName: v.orgName,
    })),
  );
});

// GET /api/vehicles/inventory-stats — 库存统计，不设数据权限，对所有人开放
app.get('/inventory-stats', async (c) => {
  const vehicles = applySubjectFilter(c, await vehicleRepository.getVehicles());
  const inventory = vehicles.filter((v) => v.status === 'Inventory' || v.status === 'Abnormal');

  const TYPE_NAME_MAP: Record<string, string> = {
    t4_5: '4.5T普货',
    t4_5c: '4.5T冷链',
    t18: '18T',
    t49: '49T',
    trailer: '挂车',
    other: '其他',
  };

  const groups = new Map<string, number>();
  for (const v of inventory) {
    const typeCategory = classifyVehicleType(v);
    const typeName = TYPE_NAME_MAP[typeCategory];
    const region = mapMacroRegion(v.province, v.city);
    const city = resolveCity(v.city, v.province);
    const brand = v.brandLabel || '未知';
    const model = v.model;
    const key = `${region}|${city}|${brand}|${typeName}|${model}`;
    groups.set(key, (groups.get(key) || 0) + 1);
  }

  const result = Array.from(groups.entries())
    .map(([key, quantity]) => {
      const [region, city, brand, type, model] = key.split('|');
      return { region, city, brand, type, model, batch: model, quantity };
    })
    .sort((a, b) => b.quantity - a.quantity);

  return c.json(result);
});

// GET /api/vehicles/weekly-detail?type=delivered|returned|replaced|pending
// Optional filters: model, batch, location, source — 按缓存车辆集合的 truck_id 交集过滤
app.get('/weekly-detail', async (c) => {
  const type = c.req.query('type');
  const { model, batch, location } = c.req.query();
  const source = c.req.query('source');
  const validTypes: WeeklyDetailType[] = ['delivered', 'returned', 'replaced', 'pending', 'new'];
  if (!validTypes.includes(type as WeeklyDetailType)) {
    return c.json([]);
  }
  let result = await vehicleRepository.getWeeklyDetailRows(type as WeeklyDetailType);

  // 按型号/批次/区域过滤：借助缓存车辆集，取 truck_id 交集
  const hasModelFilter = model && model !== 'All';
  const hasBatchFilter = batch && batch !== 'All';
  const hasLocationFilter = location && location !== 'All';
  if (hasModelFilter || hasBatchFilter || hasLocationFilter) {
    const vehicles = await getVehiclesForUser(c);
    let pool2 = vehicles;
    if (hasModelFilter) pool2 = pool2.filter((v) => v.model === model);
    if (hasBatchFilter) pool2 = pool2.filter((v) => (v.contractNo || '未知') === batch);
    if (hasLocationFilter) pool2 = filterByLocation(pool2, location, source);
    const truckSet = new Set(pool2.map((v) => String(v.id)));
    result = result.filter((r: any) => truckSet.has(String(r.truck_id)));
  }

  const masked = result.map(r => ({ ...r, customer_name: maskCustomerName(r.customer_name) }));
  return c.json(masked);
});

// GET /api/vehicles/flow-stats?start=YYYY-MM-DD&end=YYYY-MM-DD
// 资产流转日报：按提交时间(create_time)统计交车、还车、替换车，并返回可点击明细。
app.get('/flow-stats', async (c) => {
  const { start, end } = normalizeDateRange(c.req.query('start'), c.req.query('end'));
  const allowedVehicles = await getVehiclesForUser(c);
  const allowedTruckIds = new Set(allowedVehicles.map((v) => String(v.id)));

  const rows = await vehicleRepository.getFlowDetailRows(start, end);

  const details = (rows as FlowDetailRow[])
    .filter((row) => allowedTruckIds.has(String(row.truck_id)))
    .map((row) => ({
      id: row.id,
      type: row.type,
      typeLabel: row.type_label,
      date: row.stat_date,
      truckId: row.truck_id,
      plateNumber: row.plate_number,
      eventTime: row.event_time,
      submitTime: row.submit_time,
      department: row.department || '',
      manager: row.manager || '',
      customerName: maskCustomerName(row.customer_name),
    }));

  const dailyMap = new Map<string, { date: string; delivered: number; returned: number; replaced: number; total: number }>();
  for (const date of listDateRange(start, end)) dailyMap.set(date, { date, delivered: 0, returned: 0, replaced: 0, total: 0 });
  for (const item of details) {
    const stat = dailyMap.get(item.date);
    if (!stat) continue;
    stat[item.type] += 1;
    stat.total += 1;
  }

  const daily = Array.from(dailyMap.values());
  const totals = daily.reduce(
    (acc, item) => ({
      delivered: acc.delivered + item.delivered,
      returned: acc.returned + item.returned,
      replaced: acc.replaced + item.replaced,
      total: acc.total + item.total,
    }),
    { delivered: 0, returned: 0, replaced: 0, total: 0 },
  );

  return c.json({ start, end, daily, totals, details });
});

// GET /api/vehicles/subjects — 归属公司列表（含台数预览），用于顶部筛选下拉
app.get('/subjects', async (c) => {
  const all = await vehicleRepository.getVehicles();
  const user = ((c as any).get?.('user') || (c as any).var?.user) as AuthUser | undefined;
  const visible = user ? filterByPermission(all, user) : all;

  const map = new Map<string, { total: number; inventory: number; operating: number }>();
  for (const v of visible) {
    const name = (v.subjectOrg || '').trim();
    if (!name) continue;
    if (!map.has(name)) map.set(name, { total: 0, inventory: 0, operating: 0 });
    const s = map.get(name)!;
    s.total += 1;
    if (v.status === 'Inventory' || v.status === 'Abnormal') s.inventory += 1;
    if (v.status === 'Operating') s.operating += 1;
  }

  const result = Array.from(map.entries())
    .map(([name, stats]) => ({ name, ...stats }))
    .sort((a, b) => b.total - a.total);

  return c.json(result);
});

// GET /api/vehicles/refresh — force cache refresh
app.get('/refresh', async (c) => {
  vehicleRepository.invalidateRefreshCaches();
  const vehicles = await getVehiclesForUser(c);
  return c.json({ message: 'Cache refreshed', count: vehicles.length });
});

// GET /api/vehicles/debug — debug weekly date range and raw counts
app.get('/debug', async (c) => {
  const { dateRange, deliveredAll, deliveredRecent, latestTake, returnedRecent, latestReturn } = await vehicleRepository.getWeeklyDebugData();

  return c.json({
    weekRange: dateRange,
    delivered: { total: deliveredAll[0]?.cnt, thisWeek: deliveredRecent[0]?.cnt, latestDate: latestTake[0]?.latest },
    returned: { thisWeek: returnedRecent[0]?.cnt, latestDate: latestReturn[0]?.latest },
  });
});

// GET /api/vehicles/region-chart — aggregated chart data with top N + "其他"
app.get('/region-chart', async (c) => {
  const vehicles = await getVehiclesForUser(c);
  const operating = vehicles.filter((v) => v.status === 'Operating');
  const groupBy = c.req.query('groupBy') || 'region'; // 'region' | 'province'
  const source = c.req.query('source') || 'realtime'; // 'realtime' | 'vehicle'
  const top = Number(c.req.query('top')) || 8;

  let counts: Map<string, number>;
  if (groupBy === 'province') {
    counts = new Map<string, number>();
    if (source === 'vehicle') {
      // Use vehicle table's own province field
      for (const v of operating) {
        const prov = (v.province || '').replace(/省|市$/, '').trim() || '未知';
        counts.set(prov, (counts.get(prov) || 0) + 1);
      }
    } else {
      // Use realtime table province
      const rows = await vehicleRepository.getRealtimeProvinceRows();
      const plateProvince = new Map<string, string>();
      for (const row of rows as any[]) {
        const plate = (row.plate_number || '').trim();
        const prov = (row.province || '').replace(/省|市$/, '').trim();
        if (plate && prov) plateProvince.set(plate, prov);
      }
      for (const v of operating) {
        const prov = plateProvince.get(v.plateNumber) || '未知';
        counts.set(prov, (counts.get(prov) || 0) + 1);
      }
    }
  } else {
    counts = new Map<string, number>();
    for (const v of operating) {
      const key = mapMacroRegion(v.province, v.city);
      counts.set(key, (counts.get(key) || 0) + 1);
    }
  }

  // 分离"其他"和"未知"，对剩余排序取 Top N，其余全部合入"其他"
  const otherCount = (counts.get('其他') || 0) + (counts.get('未知') || 0);
  counts.delete('其他');
  counts.delete('未知');

  const sorted = Array.from(counts.entries())
    .map(([name, value]) => ({ name, value }))
    .sort((a, b) => b.value - a.value);

  const result = sorted.slice(0, top);
  const restTotal = sorted.slice(top).reduce((s, item) => s + item.value, 0) + otherCount;
  if (restTotal > 0) result.push({ name: '其他', value: restTotal });
  return c.json(result);
});

export default app;