import { flush, groupBy, isEmpty, isNotEmpty, pick, unique, uniqWith } from '@/utils/commons';
import dayjs from 'dayjs';
import { formatGroupSize } from './useProductsSets';
// Shoulder Season 平季; peak season 旺季
const isFullYearOrLonger = (year, startDate, endDate) => {
  // Parse the dates
  const start = dayjs(startDate, 'YYYY-MM-DD');
  const end = dayjs(endDate, 'YYYY-MM-DD');

  // Create the start and end dates for the year
  const yearStart = dayjs(`${year}-01-01`, 'YYYY-MM-DD');
  const yearEnd = dayjs(`${year}-12-31`, 'YYYY-MM-DD');

  // Check if start is '01-01' and end is '12-31' and the year matches
  const isFullYear = start.isSame(yearStart, 'day') && end.isSame(yearEnd, 'day');

  // Check if the range is longer than a year
  const isLongerThanYear = end.diff(startDate, 'year') >= 1;
  const isLongerThan12M = end.diff(startDate, 'month') >= 11;

  return isFullYear || isLongerThanYear || isLongerThan12M;
};

const uniqueBySub = (arr) =>
  arr.filter((subArr1, _, self) => {
    return !self.some((subArr2) => {
      if (subArr1 === subArr2) return false; // don't compare a subarray with itself
      const set1 = new Set(subArr1);
      const set2 = new Set(subArr2);
      // check if subArr1 is a subset of subArr2
      return [...set1].every((value) => set2.has(value));
    });
  });

export const chunkBy = (use_year, dataList = [], by = []) => {
  const dataRollSS = dataList.map((rowp, ii) => {
    const quotation = rowp.quotation.map((quoteItem) => {
      return {
        ...quoteItem,
        quote_season: isFullYearOrLonger(use_year, quoteItem.use_dates_start, quoteItem.use_dates_end) ? 'SS' : 'PS',
      };
    });
    return { ...rowp, quotation };
  });

  // 人等分组只取平季, 因为产品只一行
  const allQuotesSS = dataRollSS.reduce((acc, rowp) => acc.concat(rowp.quotation.filter((q) => q.quote_season === 'SS')), []);

  const allQuotesPS = dataRollSS.reduce((acc, rowp) => acc.concat(rowp.quotation.filter((q) => q.quote_season === 'PS')), []);
  const allQuotesSSS = isEmpty(allQuotesSS) ? allQuotesPS : allQuotesSS;

  const allQuotesSSS2 = [].concat(allQuotesSS, allQuotesPS);

  const PGroupSizeSS = allQuotesSSS.reduce((aq, cq) => {
    aq[cq.WPI_SN] = aq[cq.WPI_SN] || [];
    aq[cq.WPI_SN].push(`${cq.group_size_min}-${cq.group_size_max}`);
    // aq[cq.WPI_SN].push([cq.group_size_min, cq.group_size_max]);
    // aq[cq.WPI_SN].push(cq.group_size_min);
    aq[cq.WPI_SN] = unique(aq[cq.WPI_SN]);
    aq[cq.WPI_SN] = aq[cq.WPI_SN].slice().sort((a, b) => a.split('-')[0] - b.split('-')[0]);
    return aq;
  }, {});
  // debug:
  // PGroupSizeSS['5098'] = ['1-1000'];
  // PGroupSizeSS['5099'] = ['1-2', '3-4'];

  const PGroupSizePS = allQuotesPS.reduce((aq, cq) => {
    aq[cq.WPI_SN] = aq[cq.WPI_SN] || [];
    aq[cq.WPI_SN].push(`${cq.group_size_min}-${cq.group_size_max}`);
    // aq[cq.WPI_SN].push([cq.group_size_min, cq.group_size_max]);
    // aq[cq.WPI_SN].push(cq.group_size_min);
    aq[cq.WPI_SN] = unique(aq[cq.WPI_SN]);
    aq[cq.WPI_SN] = aq[cq.WPI_SN].slice().sort((a, b) => a.split('-')[0] - b.split('-')[0]);
    return aq;
  }, {});

  for (const WPI in PGroupSizeSS) {
    if (Object.prototype.hasOwnProperty.call(PGroupSizeSS, WPI)) {
      const element = PGroupSizeSS[WPI];
      const elementP = PGroupSizePS[WPI];
      const diff = (elementP || []).filter((ele, index) => !element.includes(ele));
      PGroupSizeSS[WPI] = element.concat(diff);
    }
  }

  // console.log('PGroupSizeSS', PGroupSizeSS, '\nPGroupSizePS', PGroupSizePS, '\nallQuotesSSS', allQuotesSSS2)

  // const maxGroupSize = Math.max(...allQuotesSSS.map((q) => q.group_size_max));
  // const maxSet = maxGroupSize === 1000 ? Infinity : maxGroupSize;

  const _SSMinSet = uniqWith(Object.values(PGroupSizeSS), (a, b) => a.join(',') === b.join(','));
  // const uSSsizeSetArr = (_SSMinSet)
  const uSSsizeSetArr = uniqueBySub(_SSMinSet);
  // console.log('_SSMinSet', _SSMinSet, '\n uSSsizeSetArr', uSSsizeSetArr)

  // * 若不重叠分组, 则上面不要 uniqueBySub
  for (const key in PGroupSizeSS) {
    if (Object.prototype.hasOwnProperty.call(PGroupSizeSS, key)) {
      const element = PGroupSizeSS[key];
      const findSet = uSSsizeSetArr.find((minCut) => element.every((v) => minCut.includes(v)));
      PGroupSizeSS[key] = findSet;
    }
  }
  // console.log('PGroupSizeSS -- ', PGroupSizeSS)

  const [SSsizeSets, PSsizeSets] = [uSSsizeSetArr, []].map((arr) => {
    const _arr = structuredClone(arr);
    const arrSets = _arr.map((keyMinMaxStrs) =>
      keyMinMaxStrs.reduce((acc, curr, idx, minMaxArr) => {
        const curArr = curr.split('-').map(val => parseInt(val, 10));
        acc.push(curArr);
        // const _max = idx === minsArr.length - 1 ? maxSet : Number(minsArr[idx + 1]) - 1;
        // acc.push([Number(curr), _max]);
        return acc;
      }, [])
    );
    return arrSets;
  });

  // console.log('uSSsizeSetArr', uSSsizeSetArr);
  const [SSsizeSetsMap, PSsizeSetsMap] = [uSSsizeSetArr, []].map((arr) => {
    const _arr = structuredClone(arr);
    const SetsMap = _arr.reduce((acc, keyMinMaxStrs, ii, strArr) => {
      const _key = keyMinMaxStrs.join(',');
      // console.log(_key);
      const _value = keyMinMaxStrs.reduce((acc, curr, idx, minMaxArr) => {
        const curArr = curr.split('-').map((val) => parseInt(val, 10));
        acc.push(curArr);
        return acc;
      }, []);
      return { ...acc, [_key]: _value };
    }, {});
    return SetsMap;
  });
  // console.log('SSsizeSetsMap', SSsizeSetsMap);

  const compactSizeSets = {
    SSsizeSetKey: uSSsizeSetArr.map((s) => s.join(',')).filter(isNotEmpty),
    sizeSets: SSsizeSets,
    SSsizeSetsMap,
  };
  // console.log('sizeSets -- ', SSsizeSets, '\nSSsizeSetKey', compactSizeSets.SSsizeSetKey, '\nSSsizeSetsMap', SSsizeSetsMap)

  const chunkSS = structuredClone(dataRollSS).map((rowp) => {
    const pkey = (PGroupSizeSS[rowp.info.id] || []).join(',') || compactSizeSets.SSsizeSetKey[0]; // todo:

    const _quotation = rowp.quotation.map((quoteItem) => {
      quoteItem.quote_size = pkey;
      quoteItem.quote_col_key = formatGroupSize(quoteItem.group_size_min, quoteItem.group_size_max);
      return quoteItem;
    });
    const quote_chunk_flat = groupBy(_quotation, (quoteItem2) => by.map((key) => quoteItem2[key]).join('@') || '#');
    const quote_chunk = Object.keys(quote_chunk_flat).reduce((qc, ckey) => {
      const ckeyArr = ckey.split('@');
      if (isEmpty(qc[ckeyArr[0]])) {
        qc[ckeyArr[0]] = ckeyArr[1] ? { [ckeyArr[1]]: quote_chunk_flat[ckey] } : quote_chunk_flat[ckey];
      } else {
        qc[ckeyArr[0]][ckeyArr[1]] = (qc[ckeyArr[0]][ckeyArr[1]] || []).concat(quote_chunk_flat[ckey]);
      }
      return qc;
    }, {});

    const _quotationTransposeBySize = Object.keys(quote_chunk).reduce((accBy, byKey) => {
      const byValues = quote_chunk[byKey];
      const groupTablesBySize = groupBy(byValues, 'quote_size');
      const transposeTables = Object.keys(groupTablesBySize).reduce((accBy, sizeKeys) => {
        const _sizeRows = groupTablesBySize[sizeKeys];
        const rowsByDate = groupBy(_sizeRows, qi => `${qi.use_dates_start}~${qi.use_dates_end}`);
        const _rowsFromDate = Object.keys(rowsByDate).reduce((accDate, dateKeys) => {
          const _dateRows = rowsByDate[dateKeys];
          const keepCol = pick(_dateRows[0], ['WPI_SN', 'WPP_VEI_SN', 'currency', 'unit_id', 'unit_name', 'use_dates_start', 'use_dates_end', 'weekdays', 'quote_season']);
          const _colFromDateRow = _dateRows.reduce((accCols, rowp) => {
            // const _colRow = pick(rowp, ['currency', 'unit_id', 'unit_name', 'use_dates_start', 'use_dates_end', 'weekdays', 'child_cost', 'adult_cost']);
            return { ...accCols, [rowp.quote_col_key]: rowp };
          }, {...keepCol, originRows: _dateRows });
          accDate.push(_colFromDateRow);
          return accDate;
        }, []);
        return { ...accBy, [sizeKeys]: _rowsFromDate };
      }, {});
      return { ...accBy, [byKey]: transposeTables };
    }, {});
    // console.log(_quotationTransposeBySize);

    return {
      ...rowp,
      _quotationTransposeBySize,
      sizeSetsSS: pkey,
      quotation: _quotation,
      quote_chunk,
    };
  });

  const allquotation = chunkSS.reduce((a, c) => a.concat(c.quotation), []);
  // 取出两季相应的时效区间
  const SSRange = unique((allquotation || []).filter((q) => q.quote_season === 'SS').map((qr) => `${qr.use_dates_start}~${qr.use_dates_end}`));
  const PSRange = unique((allquotation || []).filter((q) => q.quote_season === 'PS').map((qr) => `${qr.use_dates_start}~${qr.use_dates_end}`));

  // const transposeDataSS = chunkSS

  return {
    chunk: chunkSS,
    dataSource: chunkSS,
    SSRange,
    PSRange,
    ...compactSizeSets, // { SSsizeSetKey, sizeSets }
  };
};

/**
 * 按人等拆分表格
 * @use D J B R 8
 */
const splitTable_SizeSets = (chunkData) => {
  const { SSRange, PSRange, SSsizeSetKey, SSsizeSetsMap, chunk } = chunkData;
  const bySizeSetKey = groupBy(chunk, 'sizeSetsSS'); // next: city
  // agencyProducts.J.
  // console.log('bySizeSetKey', bySizeSetKey);
  const tables = Object.keys(bySizeSetKey).map((sizeSetsStr) => {
    const _thisSSsetProducts = bySizeSetKey[sizeSetsStr];
    const _subTable = _thisSSsetProducts.map(({ info, sizeSetsSS, _quotationTransposeBySize, ...pitem }) => {
      const transpose = _quotationTransposeBySize['#'][sizeSetsSS];
      const _pRow = transpose.map((quote, qi) => ({ ...quote, rowSpan: qi === 0 ? transpose.length : 0 }));
      return { info, sizeSetsSS, rows: _pRow, transpose };
    });
    return { cols: SSsizeSetsMap[sizeSetsStr], colsKey: sizeSetsStr, data: _subTable };
  });
  // console.log('---- tables', tables);
  const tablesQuote = tables.map(({ cols, colsKey, data }, ti) => {
    const _table = data.reduce((acc, prow) => {
      const prows = prow.rows.map((_q) => ({ ..._q, info: prow.info, dateText: `${_q.use_dates_start}~${_q.use_dates_end}` }));
      return acc.concat(prows);
    }, []);
    return { cols, colsKey, data: _table };
  });
  // console.log('---- tablesQuote', tablesQuote);
  return tablesQuote;
};

/**
 * 按季度分列 [平季, 旺季]
 * @use Q 7 6
 */
const splitTable_Season = (chunkData) => {
  const { SSRange, PSRange, SSsizeSetKey, SSsizeSetsMap, chunk } = chunkData;
  // console.log(chunkData);
  const tablesQuote = chunk.map((pitem) => {
    const { quote_chunk } = pitem;
    // const bySeason = groupBy(pitem.quotation, (ele) => ele.quote_season);
    const rowSeason = Object.keys(quote_chunk).reduce((accp, _s) => {
      const bySeasonValue = groupBy(quote_chunk[_s], (ele) => ['adult_cost', 'child_cost'].map((k) => ele[k]).join('@'));
    // console.log('---- bySeasonValue', bySeasonValue);

      const valUnderSeason = Object.keys(bySeasonValue).reduce((accv, valKey) => {
        const valRows = bySeasonValue[valKey];
        const valRow = pick(valRows[0], ['adult_cost', 'child_cost', 'currency', 'unit_id', 'unit_name', 'group_size_min', 'group_size_max']);
        // valRow.dates = valRows.map((v) => pick(v, ['id', 'use_dates_end', 'use_dates_start']));
        valRow.rows = valRows;
        accv.push(valRow);
        return accv;
      }, []);

      return { ...accp, [_s]: valUnderSeason };
    }, {});
    // console.log('---- rowSeason', rowSeason);
    return { info: pitem.info, ...rowSeason };
  });
  // console.log('---- tablesQuote', tablesQuote);
  return tablesQuote;
};

export const splitTable_D = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource);
  // console.log(chunked);
  return addCityRow4Split(splitTable_SizeSets(chunked));
};

export const splitTable_J = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource);
  // console.log(chunked);
  return addCityRow4Split(splitTable_SizeSets(chunked));
};

export const splitTable_Q = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource, ['quote_season']);
  return addCityRow4Season(splitTable_Season(chunked));
};

export const splitTable_7 = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource, ['quote_season']);
  return addCityRow4Season(splitTable_Season(chunked));
};

export const splitTable_R = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource);
  // console.log(chunked);
  return addCityRow4Split(splitTable_SizeSets(chunked));
};

export const splitTable_8 = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource);
  // console.log(chunked);
  return addCityRow4Split(splitTable_SizeSets(chunked));
};

export const splitTable_6 = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource, ['quote_season']);
  return (splitTable_Season(chunked));
};

export const splitTable_B = (use_year, dataSource) => {
  const chunked = chunkBy(use_year, dataSource);
  // console.log(chunked);
  return addCityRow4Split(splitTable_SizeSets(chunked));
};

export const addCityRow4Season = (table) => {
  const byCity = groupBy(table, (ele) => `${ele.info.city_id}@${ele.info.city_name}`);
  const withCityRow = Object.keys(byCity).reduce((acc, cityIdName) => {
    const [cityId, cityName] = cityIdName.split('@');
    acc.push({ info: { product_title: cityName, isCityRow: true,}, use_dates_end: '', use_dates_start: '', quote_season: 'SS', rowSpan: 1 });
    return acc.concat(byCity[cityIdName]);
  }, []);
  return withCityRow;
};

export const addCityRow4Split = (splitTables) => {
  const tables = splitTables.map(table => {
    return { ...table, data: addCityRow4Season(table.data)}
  });
  return tables;
};