import { generateQueryString } from "@/utils/queryStringUtil";
import { apiSlice } from ".";
import URLS from "./constants";

export interface ActivityCount {
  count: number;
  type: string;
}

export interface LeadStageCount {
  stageName: string;
  leadCount: number;
  absoluteChange: number;
  changeType: "increase" | "decrease" | "no change";
}

export interface PropertyCategoryCount {
  propertiesCount: number;
  categoryName: string;
  absoluteChange: number;
  changeType: "increase" | "decrease" | "no change";
}

export interface LeadInterestCount {
  totalCount: number;
  interestType: string;
  absoluteChange: number;
  changeType: "increase" | "decrease" | "no change";
}
export interface SalesData {
  contactsToLeadsPercent: number;
  leadsToCustomersPercent: number;
  taskCompletionPercent: number;
  avgDaysToClose: number;
}

export interface targetData {
  salesAmount?: { target: number; achieved: number };
  unitsSold?: { target: number; achieved: number };
  meetings?: { target: number; achieved: number };
  siteVisits?: { target: number; achieved: number };
  calls?: { target: number; achieved: number };
}

export interface stats {
  activeLeadsCount: number;
  hotLeadsCount: number;
  tasksDueTodayCount: number;
  leadsWonThisMonthCount: number;
}

/** Activity counts: use due/overdue when present, else fall back to pending for "due" */
export interface ActivityCounts {
  due?: number;
  overdue?: number;
  pending?: number;
  completed: number;
  total: number;
}

export interface TeamMember {
  name: string;
  avatar?: string;
  /** Optional role/designation shown below name (e.g. "Marketing Director") */
  role?: string;
  /** Optional organization for grouping (e.g. "Bliss Homes", "Head Office") */
  organizationName?: string;
  activities: {
    call: ActivityCounts;
    meeting: ActivityCounts;
    siteVisit: ActivityCounts;
    booking?: ActivityCounts;
  };

  totalActivitiesAssigned: number;
  teams?: { teamName: string; teamRole: string }[];
}

export interface BrokerTeamReportResponse {
  code: number;
  message: string;
  success: boolean;
  /** API may return flat TeamMember[], grouped format, or the new Report format */
  data: TeamMember[] | RawTeamActivityGroup[];
}

/** Raw team activity API shape: groups with teamName and users as name-keyed objects */
export interface RawTeamActivityGroup {
  teamName: string;
  users: Record<string, RawUserActivities>[];
  total?: {
    activities: RawGroupActivities;
    totalActivitiesAssigned?: number;
  };
}

interface RawUserActivities {
  activities: RawGroupActivities;
  roleName?: string;
}

interface RawGroupActivities {
  call?: { due?: number; overdue?: number; completed?: number };
  meetings?: { due?: number; overdue?: number; completed?: number };
  sitevisit?: { due?: number; overdue?: number; completed?: number };
  bookings?: { due?: number; overdue?: number; completed?: number };
}

/** Normalize raw activity to ActivityCounts (total = due + overdue + completed) */
function normRaw(
  a: { due?: number; overdue?: number; completed?: number } | undefined,
): ActivityCounts {
  if (!a) return { due: 0, overdue: 0, completed: 0, total: 0 };
  const due = a.due ?? 0;
  const overdue = a.overdue ?? 0;
  const completed = a.completed ?? 0;
  return { due, overdue, completed, total: due + overdue + completed };
}

/** Transform grouped team activity API response into TeamMember[] for the table */
export function transformTeamActivityResponse(
  data: TeamMember[] | RawTeamActivityGroup[] | undefined,
): TeamMember[] {
  if (!data || !Array.isArray(data) || data.length === 0) return [];
  const first = data[0];
  if (!first) return [];

  // Already flat list (legacy)
  if ("name" in first && "activities" in first) {
    return data as TeamMember[];
  }
  // Grouped format: { teamName, users: [ { "Name": { activities } }, ... ], total }
  const groups = data as RawTeamActivityGroup[];
  const result: TeamMember[] = [];
  for (const group of groups) {
    const orgName = group.teamName ?? "—";
    const userList = group.users ?? [];
    for (const userEntry of userList) {
      const name = Object.keys(userEntry)[0];
      if (!name) continue;
      const raw = userEntry[name];
      if (!raw?.activities) continue;
      const act = raw.activities;
      const call = normRaw(act.call);
      const meeting = normRaw(act.meetings);
      const siteVisit = normRaw(act.sitevisit);
      const booking = normRaw(act.bookings);
      const totalActivities =
        call.total + meeting.total + siteVisit.total + booking.total;
      result.push({
        name,
        organizationName: orgName,
        role: raw.roleName,
        activities: {
          call,
          meeting,
          siteVisit,
          booking,
        },
        totalActivitiesAssigned: totalActivities,
      });
    }
  }
  return result;
}

export interface BrokerDashboardResponse {
  code: number;
  message: string;
  success: boolean;
  data: {
    activityCounts: ActivityCount[];
    leadStageCount: LeadStageCount[];
    propertyCategoryCounts: PropertyCategoryCount[];
    leadInterestCounts: LeadInterestCount[];
    salesData: SalesData;
    targetData: targetData;
    leadSourceStats: any;
    stats: stats;
    teamSummary: TeamMember;
  };
}

// ---------- New SuperAdmin Dashboard Interfaces ----------
export interface TrendItem {
  month: string;
  value: number;
}

export interface ActiveCompanies {
  total: number;
  newThisMonth: number;
  changeType: "increase" | "decrease" | "neutral";
  brokers: number;
  builders: number;
  brokerTrend: TrendItem[];
  builderTrend: TrendItem[];
}

export interface ActiveUsers {
  currentMonthTotal: number;
  percentChange: number;
  changeType: "increase" | "decrease" | "neutral";
  trend: TrendItem[];
}

export interface FinancialSummary {
  totalValue: number;
  received: number;
  receivable: number;
  percentIncrease: number;
  changeType: "increase" | "decrease" | "neutral";
  receivedTrend: TrendItem[];
  receivableTrend: TrendItem[];
}

export interface RevenueMetric {
  value: number;
  growth: number;
  growthType: "increase" | "decrease" | "neutral";
}

export interface RevenueMetrics {
  mrr: RevenueMetric;
  arr: RevenueMetric;
  arpu: RevenueMetric;
  churnRate: RevenueMetric;
}

export interface PerformanceItem {
  value: number;
  changePercentage: number;
  changeType: "increase" | "decrease" | "neutral";
  timeframe?: string; // optional, since some items have it
  descriptor?: string; // optional, e.g. "Units + Individual"
}

export interface DataPerformance {
  contactsAdded: PerformanceItem;
  leadsAdded: PerformanceItem;
  tasksCreated: PerformanceItem;
  propertiesAdded: PerformanceItem;
  projectsAdded: PerformanceItem;
  salesMade: PerformanceItem;
}

export interface ConversionRatioMetrics {
  title: string;
  subtitle: string;
  percentage: number;
  change: number;
  changeType: "increase" | "decrease" | "no change";
  metrics: Record<string, number>;
  chartData: {
    name: string;
    value: number;
    color: string;
  }[];
}

export interface ConversionRatios {
  contactsToLeads: ConversionRatioMetrics;
  leadsToSiteVisit: ConversionRatioMetrics;
  siteVisitToBooking: ConversionRatioMetrics;
}

export interface UsageOverview {
  feature: string;
  percentage: number;
}

export interface SubscriptionsExp {
  companyName: string;
  expiresIn: number;
}

export interface LowEngagementWatchlist {
  companyName: string;
  lastActive: string;
  status: string;
}

export interface TopActiveClients {
  companyName: string;
  trend: number;
  trendType: string;
}

export interface SuperAdminDashboardResponse {
  code: number;
  message: string;
  success: boolean;
  data: {
    activeCompanies: ActiveCompanies;
    activeUsers: ActiveUsers;
    financialSummary: FinancialSummary;
    revenueMetrics: RevenueMetrics;
    dataPerformance: DataPerformance;
    conversionRatios: ConversionRatios;
    leadSources: any;
    featureUsageOverview: UsageOverview[];
    expiringSubscriptions: SubscriptionsExp[];
    lowEngagementWatchlist: LowEngagementWatchlist[];
    topActiveClients: TopActiveClients[];
  };
}

export type BrokerDashboardQueryParams = {
  startDate?: string;
  endDate?: string;
  teamId?: string;
  projectId?: string;
  source?: string;
};

export type SuperAdminDashboardQueryParams = {
  startDate?: string;
  endDate?: string;
  companyType?: "broker" | "builder";
};

export interface BuilderMetric {
  title: string;
  value: number;
  unit: string;
  change: number;
  isPositive: boolean;
}

export interface BuilderDashboardResponse {
  code: number;
  message: string;
  success: boolean;
  data: {
    metrics: BuilderMetric[];
    stats: any;
  };
}

export const dashboardApi = apiSlice.injectEndpoints({
  endpoints: (builder) => ({
    getBrokerDashboard: builder.query<
      BrokerDashboardResponse,
      BrokerDashboardQueryParams | void
    >({
      query: (params) => {
        const queryString = params
          ? generateQueryString(params as Record<string, unknown>)
          : "";

        return {
          url: `${URLS.DASHBOARD}/broker${
            queryString ? `?${queryString}` : ""
          }`,
          method: "GET",
        };
      },
      providesTags: ["Dashboard"],
    }),

    getSuperAdminDashboard: builder.query<
      SuperAdminDashboardResponse,
      SuperAdminDashboardQueryParams | void
    >({
      query: (params) => {
        // Only generate query string if params exist
        const queryString = params
          ? generateQueryString(params as Record<string, unknown>)
          : "";

        return {
          url: `${URLS.DASHBOARD}/superAdmin${
            queryString ? `?${queryString}` : ""
          }`,
          method: "GET",
        };
      },
      providesTags: ["Dashboard"],
    }),

    // Dedicated team activity report for broker dashboard (team performance section)
    getBrokerTeamReport: builder.query<
      BrokerTeamReportResponse,
      BrokerDashboardQueryParams | void
    >({
      query: (params) => {
        const queryString = params
          ? generateQueryString(params as Record<string, unknown>)
          : "";

        return {
          url: `${URLS.DASHBOARD}/broker/team-report${
            queryString ? `?${queryString}` : ""
          }`,
          method: "GET",
        };
      },
      providesTags: ["Dashboard"],
    }),
    getBuilderDashboard: builder.query<BuilderDashboardResponse, void>({
      query: () => ({
        url: `${URLS.DASHBOARD}/builder`,
        method: "GET",
      }),
      providesTags: ["Dashboard"],
    }),
  }),
  overrideExisting: false,
});

export const {
  useGetBrokerDashboardQuery,
  useGetSuperAdminDashboardQuery,
  useGetBuilderDashboardQuery,
  useGetBrokerTeamReportQuery,
} = dashboardApi;