import dayjs from "dayjs";
import { trainDataType, trainPosition } from "@/lib/trainPositionTextArray";
import { eachTrainDiagramType, StationProps } from "@/lib/CommonTypes";
type trainDataProps = {
  d: eachTrainDiagramType;
  currentTrain: trainDataType[];
  station: StationProps[];
};
export const trainTimeFiltering: (x: trainDataProps) => boolean = (props) => {
  const { d, currentTrain, station } = props;
  const baseTime = 2;
  if (currentTrain.filter((t) => t.num == d.train).length == 0) {
    const date = dayjs();
    const trainTime = date
      .hour(parseInt(d.time.split(":")[0]))
      .minute(parseInt(d.time.split(":")[1]));

    if (date.isAfter(trainTime)) {
      return false;
    } else if (trainTime.diff(date) < baseTime * 60 * 60 * 1000) {
      return true;
    }
    return false;
  } else {
    const Pos = trainPosition(currentTrain.filter((t) => t.num == d.train)[0]);
    const nextPos = Pos.isBetween ? Pos.Pos.to : Pos.Pos.Pos;
    const PrePos = Pos.isBetween ? Pos.Pos.from : "";
    if (station[0].Station_JP == nextPos) {
      if (d.lastStation != station[0].Station_JP) return true;
    } else if (station[0].Station_JP == PrePos) {
      return false;
    }
    let [h, m] = d.time.split(":");
    let delay = isNaN(currentTrain.filter((t) => t.num == d.train)[0].delay)
      ? 0
      : currentTrain.filter((t) => t.num == d.train)[0].delay;
    const date = dayjs();
    let targetHour = parseInt(h);

    // 4時を日付変更線として処理
    if (targetHour < 4) {
      targetHour += 24;
    }

    let currentHour = date.hour();
    if (currentHour < 4) {
      currentHour += 24;
    }

    const db = dayjs()
      .hour(targetHour)
      .minute(parseInt(m) + parseInt(delay));
    const currentTime = dayjs().hour(currentHour);

    return !currentTime.isAfter(db);
  }
};
type getTimeProps = (
  stationDiagram: { [key: string]: string },
  station: StationProps
) => eachTrainDiagramType[];
export const getTime: getTimeProps = (stationDiagram, station) => {
  const returnData = Object.keys(stationDiagram)
    .map((trainNum) => {
      let trainData: eachTrainDiagramType = {
        time: "",
        lastStation: "",
        isThrough: false,
        train: trainNum,
      };
      stationDiagram[trainNum].split("#").forEach((data) => {
        const [stationName, type, time] = data.split(",");
        if (!type) return;
        if (type.match("着")) {
          trainData.lastStation = stationName;
        }
        if (stationName === station.Station_JP) {
          if (type.match("発")) {
            trainData.time = time;
          } else if (type.match("通")) {
            trainData.time = time;
            trainData.isThrough = true;
          } else if (type.match("着")) {
            trainData.time = time;
          }
        }
      });
      return {
        train: trainNum,
        time: trainData.time,
        lastStation: trainData.lastStation,
        isThrough: trainData.isThrough,
      };
    })
    .filter((d) => d.time);
  return returnData.sort((a, b) => {
    const [aH, aM] = a.time.split(":");
    const [bH, bM] = b.time.split(":");
    const baseTime = dayjs();
    const aTime = baseTime.hour(parseInt(aH)).minute(parseInt(aM));
    const bTime = baseTime.hour(parseInt(bH)).minute(parseInt(bM));
    if (aTime.isBefore(bTime)) return -1;
    if (aTime.isAfter(bTime)) return 1;
    return 0;
  });
};