import { apiGet } from '@/services/api/api';
import { createAsyncThunk, createSlice, Draft, PayloadAction } from '@reduxjs/toolkit';
import { message } from 'antd';
import axios, { AxiosResponse } from 'axios';
import { ServerErrorResponse, RejectedActionPayload } from '@/interface/Shared';
import Helpers from '@/utilities/Helpers';

interface TeamMember {
  employee_id: string;
  staff_id: string;
  firstname: string;
  lastname: string;
  othername?: string;
  picture?: string;
  status: string;
  position?: { position_id: string; name: string };
  organisationUnit?: { id: string; name: string };
  employmentType?: { id: string; name: string };
  employmentStatus?: { id: string; name: string };
}

interface TeamOverview {
  total_members: number;
  active_members: number;
  gender_breakdown: Record<string, number>;
  on_probation: number;
  units: any[];
  unit_count: number;
}

interface PaginationMeta {
  current_page: number;
  last_page: number;
  per_page: number;
  total: number;
}

interface TeamState {
  members: TeamMember[];
  membersMeta: PaginationMeta | null;
  overview: TeamOverview | null;
  orgChart: any[];
  loading: boolean;
  error: string | null;
}

const initialState: TeamState = {
  members: [],
  membersMeta: null,
  overview: null,
  orgChart: [],
  loading: false,
  error: null,
};

export const fetchTeamMembers = createAsyncThunk(
  'team/FETCH_MEMBERS',
  async (params?: { search?: string; status?: string; page?: number; per_page?: number }, { rejectWithValue }) => {
    try {
      const query = new URLSearchParams();
      if (params?.search) query.set('search', params.search);
      if (params?.status) query.set('status', params.status);
      if (params?.page) query.set('page', String(params.page));
      if (params?.per_page) query.set('per_page', String(params.per_page));
      const qs = query.toString();
      const response = (await apiGet(
        `/hr/my-team/members${qs ? `?${qs}` : ''}`,
      )) as AxiosResponse<{ data: TeamMember[]; meta: PaginationMeta }>;
      return response.data;

    } catch (error) {
      if (axios.isAxiosError(error) && error.response) {
        return rejectWithValue(error.response.data as ServerErrorResponse);
      }
      throw error;
    }
  },
);

export const fetchTeamOverview = createAsyncThunk('team/FETCH_OVERVIEW', async (_, { rejectWithValue }) => {
  try {
    const response = (await apiGet('/hr/my-team/overview')) as AxiosResponse<{
      data: TeamOverview;
    }>;
    return response.data.data;

  } catch (error) {
    if (axios.isAxiosError(error) && error.response) {
      return rejectWithValue(error.response.data as ServerErrorResponse);
    }
    throw error;
  }
  });

export const fetchTeamOrgChart = createAsyncThunk('team/FETCH_ORG_CHART', async (_, { rejectWithValue }) => {
  try {
    const response = (await apiGet('/hr/my-team/org-chart')) as AxiosResponse<{ data: any[] }>;
    return response.data.data;

  } catch (error) {
    if (axios.isAxiosError(error) && error.response) {
      return rejectWithValue(error.response.data as ServerErrorResponse);
    }
    throw error;
  }
  });

export const TeamSlice = createSlice({
  name: 'team',
  initialState,
  reducers: {},
  extraReducers(builder) {
    builder
      .addCase(fetchTeamMembers.pending, (state: Draft<TeamState>) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(
        fetchTeamMembers.fulfilled,
        (
          state: Draft<TeamState>,
          action: PayloadAction<{ data: TeamMember[]; meta: PaginationMeta }>,
        ) => {
          state.members = action.payload.data;
          state.membersMeta = action.payload.meta;
          state.loading = false;
        },
      )
      .addCase(fetchTeamMembers.rejected, (state: Draft<TeamState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(fetchTeamOverview.pending, (state: Draft<TeamState>) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(
        fetchTeamOverview.fulfilled,
        (state: Draft<TeamState>, action: PayloadAction<TeamOverview>) => {
          state.overview = action.payload;
          state.loading = false;
        },
      )
      .addCase(fetchTeamOverview.rejected, (state: Draft<TeamState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(fetchTeamOrgChart.pending, (state: Draft<TeamState>) => {
        state.loading = true;
      })
      .addCase(
        fetchTeamOrgChart.fulfilled,
        (state: Draft<TeamState>, action: PayloadAction<any[]>) => {
          state.orgChart = action.payload;
          state.loading = false;
        },
      )
      .addCase(fetchTeamOrgChart.rejected, (state: Draft<TeamState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });
  },
});

export default TeamSlice;
export type { TeamState, TeamMember, TeamOverview };