import DataUnit from '../../DataUnit.js';
import { Record } from '../../interfaces/dataUnit.js';
import { Filter, Sort } from '../../metadata/UnitMetadata.js';
import { LoadDataRequest } from '../../loading/LoadDataRequest.js';
import { PaginationInfo } from '../../loading/PaginationInfo.js';
import { IColumnFilter, ColumnFilterManager } from '../../../utils/ColumnFilterManager.js';
import SortingUtils from '../../../utils/SortingUtils.js';

export class DataUnitLoaderUtils {


  public static applyFilter(records: Array<Record>, dataUnit: DataUnit, filters: Array<Filter>): Array<Record> {
    const columnFilters: Map<string, IColumnFilter> = ColumnFilterManager.getColumnFilters(filters, "");
    if (!columnFilters?.size) return records;

    const filterFunction: ((record: Record) => boolean) | undefined = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
    return (filterFunction) ? records.filter(filterFunction) : records;
  }


  public static buildLoadDataResponse(recordsIn: Array<Record>, dataUnit: DataUnit, request: LoadDataRequest) {
    let records = recordsIn ? [...recordsIn] : [];
    records = DataUnitLoaderUtils.applyFilter(records, dataUnit, request?.filters ?? []);
    records = DataUnitLoaderUtils.applySorting(records, dataUnit, request?.sort ?? []);

    const { offset, limit } = request;

    const paginationInfoBuilderParams = {
      recordsLength: records.length,
      offset,
      recordsPerPage: limit,
    } as PaginationInfoBuilderParams;

    return Promise.resolve({
      records: DataUnitLoaderUtils.getPagesByRecords(records, offset, limit),
      paginationInfo: dataUnit.pageSize ? DataUnitLoaderUtils.buildPaginationInfo(paginationInfoBuilderParams) : undefined,
    });
  }


  public static applySorting(records: Array<Record>, dataUnit: DataUnit, sorting: Array<Sort>): Array<Record> {
    if (sorting == undefined || sorting.length == 0) {
      return records;
    }
    const sortingFunction = SortingUtils.getSortingFunction(dataUnit, sorting);
    if (sortingFunction == undefined) {
      return records;
    }
    return records.sort(sortingFunction);
  }

  public static getPagesByRecords(records: Record[], offset = 0, limit = 0){
    if(!records || !records.length || !this.hasValidLimitAndOffset(offset, limit)) return [];
    if(limit === 0 && offset === 0) return records;
    return records.slice(offset, offset + limit);
  }

  private static hasValidLimitAndOffset(offset: number, limit: number) {
    return offset >= 0 && limit >= 0;
  }

  public static buildPaginationInfo({recordsLength = 0, offset = 0, recordsPerPage = 0}: PaginationInfoBuilderParams): PaginationInfo | undefined {

    if (!recordsLength) {
      return { currentPage: 0, firstRecord: 0, lastRecord: 0, total: 0, hasMore: false };
    }

    const lastRecordIndex = offset + recordsPerPage;
    const lastRecord = lastRecordIndex ? Math.min(lastRecordIndex, recordsLength) : recordsLength;

    return {
      currentPage: recordsPerPage === 0 ? 0 : Math.ceil(offset / recordsPerPage),
      firstRecord: offset + 1,
      lastRecord: lastRecord,
      total: recordsLength,
      hasMore: lastRecord < recordsLength,
    };
  }

}


export interface PaginationInfoBuilderParams {
  recordsLength: number,
  offset: number,
  recordsPerPage: number
}