import { fetchJson } from '../../auth/api-client';
import type {
  HydrogenKpi, HydrogenStationTop, HydrogenRegionShare, HydrogenMonthlyPoint, HydrogenDailyRow,
  HydrogenCustomerRow, HydrogenStationFull,
  ElectricKpi, ElectricDailyRow, ElectricMonthGroup,
  CustomerType, DateQuickPick,
  HydrogenStationBoardResponse,
  HydrogenDailyDetailResponse,
  HydrogenOverviewDetailGroupBy,
  HydrogenOverviewDetailResponse,
} from './types';

const BASE = '/api/energy';

export interface HydrogenOverviewResponse {
  kpi: HydrogenKpi;
  top5: HydrogenStationTop[];
  regions: HydrogenRegionShare[];
  monthly: HydrogenMonthlyPoint[];
  customers: HydrogenCustomerRow[];
  stations: HydrogenStationFull[];
  availableYears: number[];
  year: number;
  latestLedgerTime: string | null;
  filter: {
    stationId: number | null;
    vehicleScope: HydrogenVehicleScope;
    verifyScope: HydrogenVerifyScope;
  };
}

export type HydrogenVehicleScope = 'all' | 'lingniu' | 'external';
export type HydrogenVerifyScope = 'all' | 'verified';

export interface HydrogenOverviewQuery {
  year?: number;
  stationId?: number | null;
  vehicleScope?: HydrogenVehicleScope;
  verifyScope?: HydrogenVerifyScope;
  force?: boolean;
}

export function fetchHydrogenOverview(query: HydrogenOverviewQuery = {}): Promise<HydrogenOverviewResponse> {
  const params = new URLSearchParams();
  if (query.year) params.set('year', String(query.year));
  if (query.stationId) params.set('stationId', String(query.stationId));
  if (query.vehicleScope && query.vehicleScope !== 'all') params.set('vehicleScope', query.vehicleScope);
  if (query.verifyScope === 'verified') params.set('verifyScope', 'verified');
  if (query.force) params.set('force', '1');
  const q = params.toString();
  return fetchJson<HydrogenOverviewResponse>(`${BASE}/hydrogen/overview${q ? `?${q}` : ''}`);
}

export interface HydrogenOverviewDetailQuery {
  year: number;
  vehicleScope?: HydrogenVehicleScope;
  verifyScope?: HydrogenVerifyScope;
  stationId?: number | null;
  month?: string | null;
  date?: string | null;
  customerName?: string | null;
  customerId?: number | null;
  plateNo?: string | null;
  region?: string | null;
  regionGranularity?: 'province' | 'city';
  groupBy?: HydrogenOverviewDetailGroupBy | null;
  limit?: number;
}

export function fetchHydrogenOverviewDetail(query: HydrogenOverviewDetailQuery): Promise<HydrogenOverviewDetailResponse> {
  const params = new URLSearchParams({ year: String(query.year) });
  if (query.vehicleScope && query.vehicleScope !== 'all') params.set('vehicleScope', query.vehicleScope);
  if (query.verifyScope === 'verified') params.set('verifyScope', 'verified');
  if (query.stationId) params.set('stationId', String(query.stationId));
  if (query.month) params.set('month', query.month);
  if (query.date) params.set('date', query.date);
  if (query.customerName) params.set('customerName', query.customerName);
  if (query.customerId !== null && query.customerId !== undefined) params.set('customerId', String(query.customerId));
  if (query.plateNo) params.set('plateNo', query.plateNo);
  if (query.region) params.set('region', query.region);
  if (query.regionGranularity) params.set('regionGranularity', query.regionGranularity);
  if (query.groupBy) params.set('groupBy', query.groupBy);
  if (query.limit) params.set('limit', String(query.limit));
  return fetchJson<HydrogenOverviewDetailResponse>(`${BASE}/hydrogen/overview-detail?${params.toString()}`);
}

export interface HydrogenDailyQuery {
  range?: DateQuickPick;
  startDate?: string;
  endDate?: string;
  verifyScope?: HydrogenVerifyScope;
}

export function fetchHydrogenDaily(query: HydrogenDailyQuery, customer: CustomerType): Promise<HydrogenDailyRow[]> {
  const q = new URLSearchParams({ customer });
  if (query.range) q.set('range', query.range);
  if (query.startDate) q.set('startDate', query.startDate);
  if (query.endDate) q.set('endDate', query.endDate);
  if (query.verifyScope === 'verified') q.set('verifyScope', 'verified');
  return fetchJson<HydrogenDailyRow[]>(`${BASE}/hydrogen/daily?${q.toString()}`);
}

export function fetchHydrogenDailyDetail(
  date: string,
  customer: CustomerType,
  stationId?: number | null,
  verifyScope: HydrogenVerifyScope = 'all',
): Promise<HydrogenDailyDetailResponse> {
  const params = new URLSearchParams({ date, customer });
  if (stationId) params.set('stationId', String(stationId));
  if (verifyScope === 'verified') params.set('verifyScope', 'verified');
  return fetchJson<HydrogenDailyDetailResponse>(`${BASE}/hydrogen/daily-detail?${params.toString()}`);
}

export interface HydrogenStationBoardQuery {
  startDate: string;
  endDate: string;
  stationId?: number | null;
  force?: boolean;
}

export function fetchHydrogenStationBoard(query: HydrogenStationBoardQuery): Promise<HydrogenStationBoardResponse> {
  const params = new URLSearchParams({ startDate: query.startDate, endDate: query.endDate });
  if (query.stationId) params.set('stationId', String(query.stationId));
  if (query.force) params.set('force', '1');
  return fetchJson<HydrogenStationBoardResponse>(`${BASE}/hydrogen/station-board?${params.toString()}`);
}

export interface ElectricOverviewResponse {
  kpi: ElectricKpi;
  trend: ElectricDailyRow[];
  latestChargeTime: string | null;
}

export function fetchElectricOverview(): Promise<ElectricOverviewResponse> {
  return fetchJson<ElectricOverviewResponse>(`${BASE}/electric/overview`);
}

export function fetchElectricMonthly(customer: CustomerType, query: HydrogenDailyQuery = { range: 'last15' }): Promise<ElectricMonthGroup[]> {
  const q = new URLSearchParams({ customer });
  if (query.range) q.set('range', query.range);
  if (query.startDate) q.set('startDate', query.startDate);
  if (query.endDate) q.set('endDate', query.endDate);
  return fetchJson<ElectricMonthGroup[]>(`${BASE}/electric/monthly?${q.toString()}`);
}

export interface EtcOverviewResponse {
  tollRecordCount: number;
  vehicleCount: number;
  totalAmount: number;
  latestTollTime: string | null;
  billCount: number;
  receivableAmount: number;
  paidAmount: number;
  hasData: boolean;
}

export function fetchEtcOverview(force = false): Promise<EtcOverviewResponse> {
  return fetchJson<EtcOverviewResponse>(`${BASE}/etc/overview${force ? '?force=1' : ''}`);
}

export type HydrogenSettlementRange = DateQuickPick | 'latest';

export interface HydrogenSettlementRow {
  date: string;
  stationId: number | null;
  stationName: string;
  amount: number;
  paymentCount: number;
  matchMode: 'exact' | 'manual' | 'group' | 'unmatched';
}

export interface HydrogenSettlementResponse {
  range: { start: string | null; end: string | null; mode: HydrogenSettlementRange | 'custom' };
  summary: {
    amount: number;
    paymentCount: number;
    stationDayCount: number;
    stationCount: number;
    latestPaymentDate: string | null;
  };
  rows: HydrogenSettlementRow[];
}

export interface HydrogenSettlementQuery {
  range?: HydrogenSettlementRange | 'custom';
  startDate?: string;
  endDate?: string;
}

export function buildHydrogenSettlementQuery(query: HydrogenSettlementQuery = {}) {
  const params = new URLSearchParams();
  if (query.range) params.set('range', query.range);
  if (query.startDate) params.set('startDate', query.startDate);
  if (query.endDate) params.set('endDate', query.endDate);
  return params.toString();
}

export function fetchHydrogenSettlement(query: HydrogenSettlementQuery = {}): Promise<HydrogenSettlementResponse> {
  const q = buildHydrogenSettlementQuery(query);
  return fetchJson<HydrogenSettlementResponse>(`${BASE}/hydrogen/settlement${q ? `?${q}` : ''}`);
}