import { Component, ChangeDetectionStrategy } from "@angular/core";
import { Subject, ReplaySubject } from "rxjs";
import { takeUntil } from "rxjs/operators";
import {
  WidgetComponent,
  WidgetConfiguration,
  WidgetId,
  WidgetInput,
  WidgetOutput,
  WidgetConfigure,
} from "../../widget.metadata";
import { NgUnsubscribe } from "../../../../shared/ng-unsubscribe";
import { WidgetConfig } from "../../widget.configuration";
import { UtilService } from "../../../components/util/util.service";

const MAX_HOURS = "23";
const MAX_MINUTES = "59";
const MIN_TIME = "0";

/**
 * This class represents the job downtime widget.
 */
@WidgetComponent("nm-job-downtime")
@Component({
  selector: "nm-job-downtime",
  templateUrl: "./job-downtime.component.html",
  styleUrls: ["./job-downtime.component.scss"],
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class JobDowntimeWidget {
  private unsubscribe = NgUnsubscribe.create();

  @WidgetConfiguration()
  public configuration: WidgetConfig;

  @WidgetId()
  public _id: string;

  public selectedDay;
  public fromHourValue = "00";
  public fromMinuteValue = "00";
  public toHourValue = "00";
  public toMinuteValue = "00";
  public updatedArray = new Subject<any>();
  public selectedDays;

  public chiplistConfig;
  public selectDays = new ReplaySubject<any>(1);

  public downtimes = [];
  public errorMessage: string = "";
  public isValid: boolean = false;

  public timeIndexCounter = 8;
  public loadedTimesLength: number;

  /**
   * Channel to get cuurent job downtimes
   */
  @WidgetInput("fetchDowntimes")
  public fetchDowntimesConfig = new Subject<boolean>();

  /**
   * Emits current job downtimes
   */
  @WidgetOutput("downtimes")
  public currentDowntimes = new Subject<any>();

  /**
   * Sets loaded downtimes
   */
  @WidgetInput("loadedDowntimes")
  public loadDowntimesChannel = new Subject<any>();

  /**
   * Emits if downtimes are changed
   */
  @WidgetOutput()
  public areDowntimesChanged = new ReplaySubject<boolean>();

  constructor() {}

  @WidgetConfigure()
  protected configureWidget(configuration: WidgetConfig) {
    this.chiplistConfig = configuration.configuration.chiplistConfig;

    this.fetchDowntimesConfig
      .pipe(takeUntil(this.unsubscribe))
      .subscribe(() => this.currentDowntimes.next(this.downtimes));

    this.loadDowntimesChannel
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((times) => {
        this.loadedTimesLength = times.length;

        if (this.loadedTimesLength === 0) {
          this.areDowntimesChanged.next(false);
          this.selectDays.next([]);
          return;
        }

        this.areDowntimesChanged.next(true);
        this.downtimes = times.map((time) => {
          if (time.type !== "time") {
            time.index = time.sortIdx
              ? time.sortIdx
              : time.index
              ? time.index
              : null;
            return time;
          }
          time.index = this.timeIndexCounter;
          this.timeIndexCounter++;
          return time;
        });
        let downtimeDays = times.filter((time) => time.type !== "time");

        this.selectDays.next(downtimeDays);
      });
  }

  public validateHours() {
    this.fromHourValue = UtilService.validateTime(
      this.fromHourValue,
      MIN_TIME,
      MAX_HOURS
    );
    this.toHourValue = UtilService.validateTime(
      this.toHourValue,
      MIN_TIME,
      MAX_HOURS
    );
    this.fromMinuteValue = UtilService.validateTime(
      this.fromMinuteValue,
      MIN_TIME,
      MAX_MINUTES
    );
    this.toMinuteValue = UtilService.validateTime(
      this.toMinuteValue,
      MIN_TIME,
      MAX_MINUTES
    );

    if (!this.fromHourValue || !this.toHourValue) {
      this.isValid = false;
    } else if (this.fromHourValue < MIN_TIME || this.toHourValue < MIN_TIME) {
      this.isValid = false;
    } else if (this.fromHourValue > MAX_HOURS || this.toHourValue > MAX_HOURS) {
      this.isValid = false;
    } else {
      if (this.fromHourValue > this.toHourValue) {
        this.isValid = false;
        return;
      } else if (this.fromHourValue === this.toHourValue) {
        this.validateFromToValues();
        return;
      }
      this.isValid = true;
    }
  }

  private validateFromToValues() {
    if (this.fromMinuteValue) {
      if (!this.toMinuteValue) {
        this.isValid = false;
      } else if (this.fromMinuteValue < this.toMinuteValue) {
        this.isValid = true;
      } else {
        this.isValid = false;
      }
      return;
    }
    if (this.toMinuteValue) {
      this.isValid = true;
      return;
    }
    this.isValid = false;
  }

  public updateDowntimes(newDownTimes) {
    this.selectDays.next(newDownTimes);
    this.downtimes = newDownTimes;
    this.checkDowntimesChanged();
  }

  public getSelectedDays(days) {
    this.selectedDays = days;
    let downtimeDays = days.map((day) => {
      switch (day.index) {
        case 1:
          day.type = "sunday";
          break;
        case 2:
          day.type = "monday";
          break;
        case 3:
          day.type = "tuesday";
          break;
        case 4:
          day.type = "wednesday";
          break;
        case 5:
          day.type = "thursday";
          break;
        case 6:
          day.type = "friday";
          break;
        case 7:
          day.type = "saturday";
          break;
        default:
          break;
      }
      return { value: day.day, index: day.index, type: day.type };
    });
    let downtimes = this.downtimes.filter((time) => time["type"] === "time");
    this.downtimes = [...downtimeDays, ...downtimes];
    this.checkDowntimesChanged();
  }

  public addDownTime() {
    this.validateHours();
    let fromVal = this.fromMinuteValue
      ? this.fromHourValue + ":" + this.fromMinuteValue
      : this.fromHourValue;
    let toVal = this.toMinuteValue
      ? this.toHourValue + ":" + this.toMinuteValue
      : this.toHourValue;
    let val = fromVal + " - " + toVal;

    this.downtimes.push({
      value: val,
      index: this.timeIndexCounter,
      type: "time",
    });
    this.timeIndexCounter++;
    this.resetTimes();
    this.checkDowntimesChanged();
  }

  private resetTimes() {
    this.fromHourValue = "00";
    this.fromMinuteValue = "00";
    this.toHourValue = "00";
    this.toMinuteValue = "00";
    this.isValid = false;
  }

  private checkDowntimesChanged() {
    if (this.downtimes.length === 0 && this.loadedTimesLength === 0) {
      this.areDowntimesChanged.next(false);
    } else {
      this.areDowntimesChanged.next(true);
    }
  }
}