import type { TicketSummary } from '@/features/tickets/types/ticket.types';
import { isTicketSummary } from '@/features/tickets/types/ticket.types';

export interface SearchFilters {
  status_ids?: string[];
  priority_ids?: string[];
  category_id?: string;
  assigned_to?: string;
  requester_id?: string;
  date_from?: string;
  date_to?: string;
  sla_status?: string;
  has_attachments?: boolean;
  is_unassigned?: boolean;
  is_replied?: boolean;
}

export interface SearchRequest {
  query?: string;
  filters?: SearchFilters;
  page?: number;
  per_page?: number;
  sort_by?: string;
  sort_direction?: 'asc' | 'desc';
  department_id?: string;
}

export interface SearchPagination {
  current_page: number;
  per_page: number;
  total_pages: number;
  total_items: number;
}

export interface SearchTicketsResult {
  tickets: TicketSummary[];
  total_count: number;
  search_time_ms: number | null;
  filters_applied: SearchFilters;
  pagination: SearchPagination;
}

export interface SearchSuggestion {
  search_query: string;
  filter_data?: SearchFilters | Record<string, unknown>;
  results_count?: number;
  created_at?: string;
}

export interface QuickFilter {
  id: string;
  name: string;
  description?: string;
  icon?: string;
  filter_data?: SearchFilters | Record<string, unknown>;
}

export interface SavedFilter {
  id: string;
  name: string;
  description?: string | null;
  filter_data: SearchFilters | Record<string, unknown>;
  is_shared?: boolean;
  is_default?: boolean;
  sort_order?: number;
  created_at?: string;
  updated_at?: string;
}

export interface SavedFiltersList {
  personal: SavedFilter[];
  shared: SavedFilter[];
  quick: QuickFilter[];
}

export function isSearchSuggestion(value: unknown): value is SearchSuggestion {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const s = value as Record<string, unknown>;
  return typeof s.search_query === 'string';
}

export function isSavedFilter(value: unknown): value is SavedFilter {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const f = value as Record<string, unknown>;
  return typeof f.id === 'string' && typeof f.name === 'string' && typeof f.filter_data === 'object';
}

export function isQuickFilter(value: unknown): value is QuickFilter {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const q = value as Record<string, unknown>;
  return typeof q.id === 'string' && typeof q.name === 'string';
}

function isSearchPagination(value: unknown): value is SearchPagination {
  if (typeof value !== 'object' || value === null) {
    return false;
  }
  const p = value as Record<string, unknown>;
  return (
    typeof p.current_page === 'number' &&
    typeof p.total_items === 'number'
  );
}

export function parseTicketListFromUnknown(raw: unknown): TicketSummary[] {
  if (Array.isArray(raw) && raw.every(isTicketSummary)) {
    return raw;
  }

  if (typeof raw === 'object' && raw !== null && 'data' in raw) {
    const inner = (raw as { data: unknown }).data;
    if (Array.isArray(inner) && inner.every(isTicketSummary)) {
      return inner;
    }
  }

  return [];
}

export function parseSearchTicketsResult(raw: unknown): SearchTicketsResult {
  if (typeof raw !== 'object' || raw === null) {
    throw new Error('Invalid search response');
  }

  const envelope = raw as Record<string, unknown>;
  const data =
    envelope.success === true && typeof envelope.data === 'object' && envelope.data !== null
      ? (envelope.data as Record<string, unknown>)
      : envelope;

  const ticketsRaw = data.tickets;
  const tickets = parseTicketListFromUnknown(ticketsRaw);

  const paginationRaw = data.pagination;
  const pagination: SearchPagination = isSearchPagination(paginationRaw)
    ? paginationRaw
    : {
        current_page: 1,
        per_page: tickets.length,
        total_pages: 1,
        total_items: typeof data.total_count === 'number' ? data.total_count : tickets.length,
      };

  return {
    tickets,
    total_count:
      typeof data.total_count === 'number' ? data.total_count : pagination.total_items,
    search_time_ms: typeof data.search_time_ms === 'number' ? data.search_time_ms : null,
    filters_applied:
      typeof data.filters_applied === 'object' && data.filters_applied !== null
        ? (data.filters_applied as SearchFilters)
        : {},
    pagination,
  };
}

export function buildSearchFiltersPayload(filters: SearchFilters): Record<string, unknown> {
  const payload: Record<string, unknown> = {};

  if (filters.status_ids?.length) {
    payload.status_ids = filters.status_ids;
  }
  if (filters.priority_ids?.length) {
    payload.priority_ids = filters.priority_ids;
  }
  if (filters.category_id) {
    payload.category_id = filters.category_id;
  }
  if (filters.assigned_to) {
    payload.assigned_to = filters.assigned_to;
  }
  if (filters.requester_id) {
    payload.requester_id = filters.requester_id;
  }
  if (filters.date_from) {
    payload.date_from = filters.date_from;
  }
  if (filters.date_to) {
    payload.date_to = filters.date_to;
  }
  if (filters.sla_status) {
    payload.sla_status = filters.sla_status;
  }
  if (filters.has_attachments !== undefined) {
    payload.has_attachments = filters.has_attachments;
  }
  if (filters.is_unassigned !== undefined) {
    payload.is_unassigned = filters.is_unassigned;
  }
  if (filters.is_replied !== undefined) {
    payload.is_replied = filters.is_replied;
  }

  return payload;
}