'use client';

import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
import {
  getLaunch,
  getLaunchs,
  getProject,
  getProjects,
  updateProjectData,
  updateLaunchData,
  updateSwitch,
  getFacebookData,
  getProjectChannel,
  getLeadRequestsByLaunch,
  getLaunchCreatedBy,
  getProjectCreatedBy,
  getProjectRegion,
} from './service';
import { LIST_META } from '@/utills/constant';
import type { LaunchPayload, LaunchTeamI, UserStates } from './interface';
import { removeEmptyKeys } from '@/utills/helper';

const initialState: UserStates = {
  faceBookList: [],
  regionList: [],
  projectEmpList: [],
  launchEmpList: [],
  launches: [],
  launchesId: {},
  channelID: {},
  projects: [],
  projectId: {},
  launchMeta: LIST_META,
  projectMeta: LIST_META,
  switch: '',
  listLoading: true,
  status: 'loading',
  loading: true,
  launchLoading: true,
  channelLoading: true,
  error: null,
  faceBookMeta: LIST_META,
};

export const fetchLaunchs = createAsyncThunk(
  'launches/fetchLaunchs',
  async(payload: any) => {
    const queryString = removeEmptyKeys(payload) as LaunchPayload;
    const launches = await getLaunchs(queryString);
    return launches;
  }
);

export const fetchLaunch = createAsyncThunk('launches/fetchLaunch', async(payload: any) => {
  const launches = await getLaunch(payload.id, payload.params);
  return launches;
});

export const updateLaunch = createAsyncThunk(
  'launches/updateLaunch',
  async({ launchID, launchData }: { launchID: number; launchData: any }) => {
    const updatedLaunch = await updateLaunchData(launchID, launchData);
    return updatedLaunch;
  }
);

export const launchStatusUpdate = createAsyncThunk(
  'launches/launchStatusUpdate',
  async({ launchId, launchData }: { launchId: number; launchData: any }) => {
    const changeSwitch = await updateSwitch(launchId, launchData);
    return changeSwitch;
  }
);

export const fetchProjects = createAsyncThunk(
  'launches/fetchProjects',
  async(payload: any) => {
    const queryString = removeEmptyKeys(payload);
    const projects = await getProjects(queryString);
    return projects;
  }
);

export const fetchProject = createAsyncThunk(
  'launches/fetchProject',
  async({ id }: { id: number | string }) => {
    const launches = await getProject(id);
    return launches;
  }
);

export const updateProject = createAsyncThunk(
  'launches/updateProject',
  async({ id, data }: { id: number; data: any }) => {
    const queryString = removeEmptyKeys(data);
    const updatedProject = await updateProjectData(id, queryString);
    return updatedProject;
  }
);

export const fetchFacebookFormList = createAsyncThunk(
  'launches/fetchFacebookFormList',
  async(payload: any) => {
    const queryString = removeEmptyKeys(payload);
    const faceBookList = await getFacebookData(queryString);
    return faceBookList;
  }
);

export const fetchProjectChannel = createAsyncThunk(
  'launches/fetchProjectChannel',
  async(payload: any) => {
    const projectChannel = await getProjectChannel(payload);
    return projectChannel;
  }
);

export const fetchLeadRequestByLaunch = createAsyncThunk(
  'launches/fetchLeadRequestByLaunch',
  async({ id }: { id: number | string }) => {
    const launchLeads = await getLeadRequestsByLaunch(id);
    return launchLeads;
  }
);

export const fetchCreatedByEmployee = createAsyncThunk(
  'launches/fetchCreatedByEmployee',
  async(payload: any) => {
    console.log(payload)
    const createdBy = await getLaunchCreatedBy();
    return createdBy;
  }
);

export const fetchCreatedByProjectEmployee = createAsyncThunk(
  'launches/fetchCreatedByProjectEmployee',
  async(payload: any) => {
    console.log(payload)
    const createBy = await getProjectCreatedBy();
    return createBy;
  }
);

export const fetchProjectRegions = createAsyncThunk(
  'launches/fetchProjectRegions',
  async(payload: any) => {
    console.log(payload)
    const project = await getProjectRegion();
    return project;
  }
);

const LaunchSlice = createSlice({
  name: 'launches',
  initialState,
  reducers: {
    addLaunchTeam: (state, action) => {
      const newLaunchTeam = action.payload; // Assuming you pass the new team object in action.payload.newTeam

      // Create a new array by adding the new team to the existing launch_sales array
      const updatedLaunchSales = [...state.launchesId.launch_sales, newLaunchTeam];
      state.launchesId.launch_sales = updatedLaunchSales;

      return;
    },
    editLaunchTeam: (state, action) => {
      const editedTeam = action.payload;
      // Create a new array by mapping over the existing launch_sales array and replacing the team with the same teamId
      const updatedLaunchSales = state.launchesId.launch_sales.map((team: LaunchTeamI) =>
        team.id === editedTeam.id ? editedTeam : team
      );
      state.launchesId.launch_sales = updatedLaunchSales;
      return;
    },
    deleteLaunchTeam: (state, action) => {
      const teamId = action.payload.id;
      // Filter out the item with the matching id
      const updatedLaunchSales = state.launchesId.launch_sales.filter(
        (item: LaunchTeamI) => item.id !== teamId
      );
      state.launchesId.launch_sales = updatedLaunchSales;
    },
  },
  extraReducers: (builder) => {
    builder
      .addCase(fetchLaunchs.pending, (state) => {
        state.status = 'loading';
        state.listLoading = true;
      })
      .addCase(fetchLaunchs.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.listLoading = false;
        state.launches = action.payload;
        state.launchMeta = action.payload.meta;
      })
      .addCase(fetchLaunchs.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.listLoading = false;
        state.error = action.error.message;
      })

      .addCase(fetchLaunch.pending, (state) => {
        state.status = 'loading';
        state.launchLoading = true;
      })
      .addCase(fetchLaunch.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.launchLoading = false;
        state.launchesId = action.payload.data;
      })
      .addCase(fetchLaunch.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.launchLoading = false;
        state.error = action.error.message;
      })
      .addCase(fetchProjectChannel.pending, (state) => {
        state.status = 'loading';
        state.channelLoading = true;
      })
      .addCase(fetchProjectChannel.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.channelLoading = false;
        state.channelID = action.payload.data;
      })
      .addCase(fetchProjectChannel.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.channelLoading = false;
        state.error = action.error.message;
      })
      .addCase(fetchProject.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchProject.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.projectId = action.payload.data;
      })
      .addCase(fetchProject.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.error = action.error.message;
      })
      .addCase(fetchProjects.pending, (state) => {
        state.status = 'loading';
        state.listLoading = true;
      })
      .addCase(fetchProjects.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.projects = action.payload;
        state.projectMeta = action.payload.meta;

        state.listLoading = false;
      })
      .addCase(fetchProjects.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message ?? 'error';
        state.listLoading = false;
      })
      .addCase(launchStatusUpdate.pending, (state) => {
        state.loading = true;
      })
      .addCase(launchStatusUpdate.fulfilled, (state: UserStates, action) => {
        state.loading = false;
        state.launchesId = {
          ...state.launchesId,
          status: action.meta.arg.launchData.status,
        };
      })
      .addCase(launchStatusUpdate.rejected, (state, action) => {
        state.loading = false;
        state.error = action.error.message ?? 'error';
      })
      .addCase(fetchFacebookFormList.pending, (state) => {
        state.status = 'loading';
        state.listLoading = true;
      })
      .addCase(fetchFacebookFormList.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.listLoading = false;
        state.faceBookList = action.payload.data;
        state.faceBookMeta = action.payload.meta;
      })
      .addCase(fetchFacebookFormList.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.listLoading = false;
        state.error = action.error.message;
      })
      .addCase(fetchLeadRequestByLaunch.pending, (state) => {
        state.status = 'loading';
        state.listLoading = true;
      })
      .addCase(fetchLeadRequestByLaunch.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.listLoading = false;
        state.leadList = action.payload.data;
      })
      .addCase(fetchLeadRequestByLaunch.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.listLoading = false;
        state.error = action.error.message;
      })

      .addCase(fetchCreatedByEmployee.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchCreatedByEmployee.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.launchEmpList = action.payload.data;
      })
      .addCase(fetchCreatedByEmployee.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.error = action.error.message;
      })

      .addCase(fetchCreatedByProjectEmployee.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchCreatedByProjectEmployee.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.projectEmpList = action.payload.data;
      })
      .addCase(fetchCreatedByProjectEmployee.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.error = action.error.message;
      })

      .addCase(fetchProjectRegions.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchProjectRegions.fulfilled, (state: UserStates, action) => {
        state.status = 'succeeded';
        state.regionList = action.payload.data;
      })
      .addCase(fetchProjectRegions.rejected, (state: UserStates, action: any) => {
        state.status = 'failed';
        state.error = action.error.message;
      });
  },
});

export const selectLaunchList = (state: { user: { userList: void; }; }): void => state.user.userList;

export const { addLaunchTeam, editLaunchTeam, deleteLaunchTeam } = LaunchSlice.actions;

export default LaunchSlice.reducer;