import { FilterCategory, FilterKey } from 'Types/filter/filterType';
import {
  filtersMap,
  generateFilterOptions,
  liveFiltersMap
} from 'Types/filter/newFilter';
import { List } from 'immutable';
import { makeAutoObservable, reaction } from 'mobx';
import Search from 'App/mstore/types/search';
import { checkFilterValue, IFilter } from 'App/mstore/types/filter';
import FilterItem from 'App/mstore/types/filterItem';
import { sessionStore } from 'App/mstore';
import { searchService } from 'App/services';

const PER_PAGE = 10;

export const checkValues = (key: any, value: any) => {
  if (key === FilterKey.DURATION) {
    return value[0] === '' || value[0] === null ? [0, value[1]] : value;
  }
  return value.filter((i: any) => i !== '' && i !== null);
};

export const filterMap = ({
                            category,
                            value,
                            key,
                            operator,
                            sourceOperator,
                            source,
                            custom,
                            isEvent,
                            filters,
                            sort,
                            order
                          }: any) => ({
  value: checkValues(key, value),
  custom,
  type: category === FilterCategory.METADATA ? FilterKey.METADATA : key,
  operator,
  source: category === FilterCategory.METADATA ? key.replace(/^_/, '') : source,
  sourceOperator,
  isEvent,
  filters: filters ? filters.map(filterMap) : []
});

class SearchStoreLive {
  list = List();
  latestRequestTime: number | null = null;
  latestList = List();
  alertMetricId: number | null = null;
  instance = new Search({ sort: 'timestamp', order: 'desc' });
  instanceLive = new Search();
  savedSearch = new Search();
  filterSearchList: any = {};
  currentPage = 1;
  pageSize = PER_PAGE;
  activeTab = { name: 'All', type: 'all' };
  scrollY = 0;
  sessions = List();
  total: number = 0;
  loadingFilterSearch = false;

  constructor() {
    makeAutoObservable(this);

    // Reset currentPage to 1 only on filter changes
    reaction(
      () => this.instance,
      () => {
        this.currentPage = 1;
        void this.fetchSessions();
      }
    );

    // Fetch sessions when currentPage changes
    reaction(
      () => this.currentPage,
      () => {
        void this.fetchSessions();
      }
    );
  }

  get filterList() {
    return generateFilterOptions(filtersMap);
  }

  get filterListLive() {
    return generateFilterOptions(liveFiltersMap);
  }

  fetchFilterSearch = async (params: any): Promise<void> => {
    this.loadingFilterSearch = true;

    try {
      const response: any[] = await searchService.fetchFilterSearch(params);

      this.filterSearchList = response.reduce(
        (acc: Record<string, { projectId: number; value: string }[]>, item: any) => {
          const { projectId, type, value } = item;
          if (!acc[type]) acc[type] = [];
          acc[type].push({ projectId, value });
          return acc;
        },
        {}
      );
    } catch (error) {
      console.error('Error fetching filter search:', error);
    } finally {
      this.loadingFilterSearch = false;
    }
  };

  edit(instance: Partial<Search>) {
    this.instance = new Search(Object.assign({ ...this.instance }, instance));
  }


  apply(filter: any, fromUrl: boolean) {
    if (fromUrl) {
      this.instance = new Search(filter);
    } else {
      this.instance = { ...this.instance, ...filter };
    }
  }

  applyFilter(filter: any, force = false) {
    this.apply(filter, false);
  }

  updateCurrentPage(page: number) {
    this.currentPage = page;
  }

  clearSearch() {
    const instance = this.instance;
    this.edit(new Search({
      rangeValue: instance.rangeValue,
      startDate: instance.startDate,
      endDate: instance.endDate,
      filters: []
    }));
  }

  addFilter(filter: any) {
    const index = this.instance.filters.findIndex((i: FilterItem) => i.key === filter.key);

    filter.value = checkFilterValue(filter.value);
    filter.filters = filter.filters
      ? filter.filters.map((subFilter: any) => ({
        ...subFilter,
        value: checkFilterValue(subFilter.value)
      }))
      : null;

    if (index > -1) {
      // Update existing filter
      // @ts-ignore
      this.instance.filters[index] = {
        ...this.instance.filters[index],
        value: this.instance.filters[index].value.concat(filter.value)
      };
    } else {
      // Add new filter (create a new array reference to notify MobX)
      this.instance.filters = [...this.instance.filters, filter];
    }

    // Update the instance to trigger reactions
    this.instance = new Search({
      ...this.instance.toData()
    });

    // if (filter.value && filter.value[0] && filter.value[0] !== '') {
    //   void this.fetchSessions();
    // }
  }

  addFilterByKeyAndValue(key: any, value: any, operator?: string, sourceOperator?: string, source?: string) {
    let defaultFilter = { ...filtersMap[key] };
    defaultFilter.value = value;

    if (operator) {
      defaultFilter.operator = operator;
    }
    if (defaultFilter.hasSource && source && sourceOperator) {
      defaultFilter.sourceOperator = sourceOperator;
      defaultFilter.source = source;
    }

    this.addFilter(defaultFilter);
  }

  updateFilter = (index: number, search: Partial<IFilter>) => {
    const newFilters = this.instance.filters.map((_filter: any, i: any) => {
      if (i === index) {
        return search;
      } else {
        return _filter;
      }
    });

    this.instance = new Search({
      ...this.instance.toData(),
      filters: newFilters
    });
  };

  removeFilter = (index: number) => {
    const newFilters = this.instance.filters.filter((_filter: any, i: any) => {
      return i !== index;
    });

    this.instance = new Search({
      ...this.instance.toData(),
      filters: newFilters
    });
  };

  async fetchSessions() {
    await sessionStore.fetchLiveSessions({ ...this.instance.toSearch(), page: this.currentPage });
  };
}

export default SearchStoreLive;