export interface ChartDataset {
  labels: string[];
  data: number[];
}

export interface TicketTrendsDataset {
  label: string;
  data: number[];
}

export interface TicketTrends {
  labels: string[];
  datasets: TicketTrendsDataset[];
}

export interface AssigneePerformanceItem {
  user_id: string;
  user_name: string;
  user_email: string;
  tickets_handled: number;
  tickets_closed: number;
  avg_response_time_hours: number;
  close_rate: number;
}

export interface AssigneePerformanceResponse {
  assignees: AssigneePerformanceItem[];
}

export interface DashboardOverviewStats {
  total_tickets: number;
  open_tickets: number;
  closed_tickets: number;
  tickets_today: number;
  avg_response_time_hours: number;
  avg_resolution_time_hours: number;
  sla_compliance_rate: number;
  overdue_tickets: number;
  tickets_this_week: number;
  tickets_this_month: number;
  sla_met: number;
  sla_warning: number;
  sla_breached: number;
}

export interface DashboardSlaMetrics {
  total: number;
  met: number;
  warning: number;
  breached: number;
  active: number;
  paused: number;
  compliance_rate: number;
}

export interface DashboardRecentTicket {
  id: string;
  ticket_number: string;
  subject: string;
  department_id: string;
  assignee_id: string | null;
  status: string;
  priority: string | null;
  created_at: string;
  updated_at: string;
  closed_at: string | null;
}

export interface DashboardRecentProject {
  id: string;
  name: string;
  key: string;
  status: string;
  department_id: string;
  updated_at: string;
}

function unwrapDashboardPayload(raw: unknown): unknown {
  if (typeof raw !== 'object' || raw === null || !('data' in raw)) {
    return raw;
  }

  const inner = (raw as { data: unknown }).data;
  return typeof inner === 'object' && inner !== null ? inner : raw;
}

function normalizeChartDataset(value: unknown): ChartDataset {
  if (typeof value !== 'object' || value === null) {
    return { labels: [], data: [] };
  }

  const record = value as Record<string, unknown>;
  return {
    labels: Array.isArray(record.labels) ? record.labels.map(String) : [],
    data: Array.isArray(record.data) ? record.data.map((entry) => Number(entry)) : [],
  };
}

function normalizeRecentProject(value: unknown): DashboardRecentProject | null {
  if (typeof value !== 'object' || value === null) {
    return null;
  }

  const record = value as Record<string, unknown>;
  if (
    typeof record.id !== 'string' ||
    typeof record.name !== 'string' ||
    typeof record.key !== 'string' ||
    record.status == null ||
    record.updated_at == null
  ) {
    return null;
  }

  return {
    id: record.id,
    name: record.name,
    key: record.key,
    status: String(record.status),
    department_id: typeof record.department_id === 'string' ? record.department_id : '',
    updated_at: String(record.updated_at),
  };
}

export interface DashboardOverview {
  audience: string;
  stats: DashboardOverviewStats;
  sla: DashboardSlaMetrics;
  charts: {
    tickets_by_status: ChartDataset;
    tickets_by_priority: ChartDataset;
    tickets_by_category: ChartDataset;
    sla_status: ChartDataset;
  };
  recent_tickets: DashboardRecentTicket[];
  recent_projects?: DashboardRecentProject[];
}

function isChartDataset(value: unknown): value is ChartDataset {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const record = value as Record<string, unknown>;
  return Array.isArray(record.labels) && Array.isArray(record.data);
}

function isStats(value: unknown): value is DashboardOverviewStats {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const s = value as Record<string, unknown>;
  return (
    typeof s.total_tickets === 'number' &&
    typeof s.open_tickets === 'number' &&
    typeof s.closed_tickets === 'number' &&
    typeof s.avg_response_time_hours === 'number' &&
    typeof s.avg_resolution_time_hours === 'number' &&
    typeof s.sla_compliance_rate === 'number'
  );
}

function isTicketTrends(value: unknown): value is TicketTrends {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const record = value as Record<string, unknown>;
  if (!Array.isArray(record.labels) || !Array.isArray(record.datasets)) {
    return false;
  }
  return record.datasets.every((dataset) => {
    if (typeof dataset !== 'object' || dataset === null) {
      return false;
    }
    const item = dataset as Record<string, unknown>;
    return typeof item.label === 'string' && Array.isArray(item.data);
  });
}

function isAssigneePerformanceItem(value: unknown): value is AssigneePerformanceItem {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const item = value as Record<string, unknown>;
  return (
    typeof item.user_id === 'string' &&
    typeof item.user_name === 'string' &&
    typeof item.tickets_handled === 'number' &&
    typeof item.tickets_closed === 'number'
  );
}

export function isAssigneePerformanceResponse(
  value: unknown,
): value is AssigneePerformanceResponse {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const record = value as Record<string, unknown>;
  return (
    Array.isArray(record.assignees) &&
    record.assignees.every((item) => isAssigneePerformanceItem(item))
  );
}

export function isDashboardOverview(value: unknown): value is DashboardOverview {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const record = value as Record<string, unknown>;
  const charts = record.charts;
  if (typeof charts !== 'object' || charts === null) {
    return false;
  }
  const chartRecord = charts as Record<string, unknown>;
  return (
    typeof record.audience === 'string' &&
    isStats(record.stats) &&
    typeof record.sla === 'object' &&
    record.sla !== null &&
    isChartDataset(chartRecord.tickets_by_status) &&
    isChartDataset(chartRecord.tickets_by_priority) &&
    Array.isArray(record.recent_tickets) &&
    (record.recent_projects === undefined ||
      record.recent_projects === null ||
      Array.isArray(record.recent_projects))
  );
}

export function parseDashboardOverview(raw: unknown): DashboardOverview {
  const payload = unwrapDashboardPayload(raw);

  if (!isDashboardOverview(payload)) {
    throw new Error('Invalid dashboard overview response');
  }

  const record = payload as DashboardOverview;
  const charts = record.charts as Record<string, unknown>;

  return {
    ...record,
    charts: {
      tickets_by_status: normalizeChartDataset(charts.tickets_by_status),
      tickets_by_priority: normalizeChartDataset(charts.tickets_by_priority),
      tickets_by_category: normalizeChartDataset(charts.tickets_by_category),
      sla_status: normalizeChartDataset(charts.sla_status),
    },
    recent_projects: (Array.isArray(record.recent_projects) ? record.recent_projects : [])
      .map(normalizeRecentProject)
      .filter((project): project is DashboardRecentProject => project !== null),
  };
}

export function isTicketTrendsResponse(value: unknown): value is TicketTrends {
  return isTicketTrends(value);
}