import { Component } from "@angular/core";
import { Subject, ReplaySubject } from "rxjs";
import { TranslateService } from "@ngx-translate/core";
import { FormControl } from "@angular/forms";
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 { WeekDay } from "../../../components/week-day-selector/week-day-selector.component";
import { WidgetframeService } from "../../widgetframe/widgetframe.service";
import { UtilService } from "../../../components/util/util.service";

const MAX_MONTH_DAYS = "31";
const MAX_HOURS = "23";
const MAX_MINUTES = "59";
const MIN_VALUE = "0";

export enum JobTypes {
  MANUALLY = "IMMEDIATE",
  EVERY_MONTH = "MONTHLY",
  EVERY_WEEK = "WEEKLY",
  EVERY_DAY = "DAILY",
  EVERY_HOUR = "HOURLY",
  EVERY_MINUTE = "MINUTELY",
  EVERY_SECOND = "SECONDLY",
}

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

  @WidgetConfiguration()
  public configuration: WidgetConfig;

  @WidgetId()
  public _id: string;

  /**
   * Channel to get cuurent job settings configurations
   */
  @WidgetInput("fetchJobSettings")
  public fetchSettingsConfig = new Subject<boolean>();

  /**
   * Emits cuurent job settings configurations
   */
  @WidgetOutput("jobSettings")
  public jobSettingsConfig = new Subject<any>();

  /**
   * Emits the data validity based on job type
   */
  @WidgetOutput("isValidData")
  public isValidData = new ReplaySubject<any>();

  /**
   * Sets loaded settings
   */
  @WidgetInput("loadSettings")
  public loadSettingsUriChannel = new Subject<any>();

  public selectedDayObservable = new Subject<any>();
  public filterCtrl: FormControl = new FormControl();
  public resetSelection = new Subject<any>();

  public jobTypes: any[];

  public initialOptions: any;

  public disableSlider = true;
  public disableWeekDays = true;
  public disableMonthDays = true;
  public disableHours = true;
  public disableMinutes = true;

  public selectedDay: WeekDay[] = [];
  public jobType: string;
  public interval: any = 1;
  public monthDay;
  public hourValue;
  public minutValue;
  public maxValue = 23;
  public settingsConfig: any = {};
  public selectDays = new ReplaySubject<any>(1);

  constructor(
    private widgetFrameService: WidgetframeService,
    private translateService: TranslateService
  ) {}

  @WidgetConfigure()
  protected configureWidget(configuration: WidgetConfig) {
    this.widgetFrameService
      .getData(this.configuration.configuration.jobTypeUrl)
      .subscribe((response) => {
        this.jobTypes = response._embedded["job-types"];
        this.initialOptions = this.jobTypes;
      });

    this.filterCtrl.valueChanges
      .pipe(takeUntil(this.unsubscribe))
      .subscribe(() => {
        this.filterOptions();
      });

    this.selectedDayObservable
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((value) => {
        this.selectedDay = value.index;
      });

    this.fetchSettingsConfig.pipe(takeUntil(this.unsubscribe)).subscribe(() => {
      this.settingsConfig.jobType = this.jobType;
      this.settingsConfig.interval = this.getInterval();
      this.settingsConfig.minutes = this.minutValue;
      this.settingsConfig.hours = this.hourValue;
      this.settingsConfig.time = this.getTime();
      this.settingsConfig.weekDay = this.selectedDay[0];
      this.settingsConfig.dayOfMonth = this.monthDay;

      this.jobSettingsConfig.next(this.settingsConfig);
    });

    this.loadSettingsUriChannel
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((setting) => {
        if (!setting) {
          return;
        }
        this.monthDay = setting.dayOfMonth;
        this.interval = setting.interval;
        this.jobType = setting.jobType;
        this.hourValue = setting.hours;
        this.minutValue = setting.minutes;
        if (this.jobType === JobTypes.EVERY_WEEK) {
          this.selectDays.next([{ index: Number(setting.weekDay.index) }]);
        }
        this.checkValidInputs();
        this.adjustTriggerInputs();
      });
  }

  getSelectedDay(day) {
    this.selectedDay = [];
    this.selectedDay.push(day);
    this.checkValidInputs();
  }

  public onChange() {
    this.resetValues();
    this.checkValidInputs();
    this.settingsConfig = {};
    this.adjustTriggerInputs();
  }

  private adjustTriggerInputs() {
    switch (this.jobType) {
      case JobTypes.MANUALLY:
        this.adjustToManuallyTrigger();
        break;
      case JobTypes.EVERY_SECOND:
        this.adjustToSecondlyTrigger();
        break;
      case JobTypes.EVERY_MINUTE:
        this.adjustToMinutlyTrigger();
        break;
      case JobTypes.EVERY_HOUR:
        this.adjustToHourlyTrigger();
        break;
      case JobTypes.EVERY_DAY:
        this.adjustToDailyTrigger();
        break;
      case JobTypes.EVERY_WEEK:
        this.adjustToWeeklyTrigger();
        break;
      case JobTypes.EVERY_MONTH:
        this.adjustToMonthlyTrigger();
        break;
    }
  }

  private getInterval(): any {
    switch (this.jobType) {
      case JobTypes.EVERY_SECOND:
      case JobTypes.EVERY_MINUTE:
      case JobTypes.EVERY_HOUR:
        return this.interval;
      default:
        return null;
    }
  }
  public checkValidInputs() {
    switch (this.jobType) {
      case JobTypes.MANUALLY:
        this.isValidData.next(true);
        break;

      case JobTypes.EVERY_SECOND:
      case JobTypes.EVERY_MINUTE:
      case JobTypes.EVERY_HOUR:
      case JobTypes.EVERY_DAY:
        this.validateIntervalJobs();
        break;

      case JobTypes.EVERY_WEEK:
        this.validateWeeklyJobs();
        break;

      case JobTypes.EVERY_MONTH:
        this.validateMonthlyJobs();
        break;
    }
  }

  private validateMonthlyJobs() {
    if (
      this.monthDay &&
      (this.hourValue || this.hourValue === 0) &&
      (this.minutValue || this.minutValue === 0)
    ) {
      this.isValidData.next(true);
      return;
    }
    this.isValidData.next(false);
  }

  private validateWeeklyJobs() {
    if (
      this.selectedDay[0] &&
      (this.hourValue || this.hourValue === 0) &&
      (this.minutValue || this.minutValue === 0)
    ) {
      this.isValidData.next(true);
      return;
    }
    this.isValidData.next(false);
  }

  private validateIntervalJobs() {
    if (
      (this.hourValue || this.hourValue === 0) &&
      (this.minutValue || this.minutValue === 0)
    ) {
      this.isValidData.next(true);
      return;
    }
    this.isValidData.next(false);
  }

  private adjustToMonthlyTrigger() {
    this.disableWeekDays = true;
    this.disableMonthDays = false;
    this.disableSlider = true;
    this.disableHours = false;
    this.disableMinutes = false;
  }

  private adjustToWeeklyTrigger() {
    this.disableWeekDays = false;
    this.disableMonthDays = true;
    this.disableSlider = true;
    this.disableHours = false;
    this.disableMinutes = false;
  }

  private adjustToDailyTrigger() {
    this.disableWeekDays = true;
    this.disableMonthDays = true;
    this.disableSlider = true;
    this.disableHours = false;
    this.disableMinutes = false;
  }

  private adjustToHourlyTrigger() {
    this.maxValue = 23;
    this.disableWeekDays = true;
    this.disableMonthDays = true;
    this.disableSlider = false;
    this.disableHours = false;
    this.disableMinutes = false;
  }

  private adjustToMinutlyTrigger() {
    this.maxValue = 59;
    this.disableWeekDays = true;
    this.disableMonthDays = true;
    this.disableSlider = false;
    this.disableHours = false;
    this.disableMinutes = false;
  }

  private adjustToSecondlyTrigger() {
    this.maxValue = 59;
    this.disableWeekDays = true;
    this.disableMonthDays = true;
    this.disableSlider = false;
    this.disableHours = false;
    this.disableMinutes = false;
  }

  private adjustToManuallyTrigger() {
    this.disableWeekDays = true;
    this.disableMonthDays = true;
    this.disableSlider = true;
    this.disableHours = true;
    this.disableMinutes = true;
    this.hourValue = null;
    this.minutValue = null;
    this.interval = null;
  }

  private resetValues() {
    this.monthDay = null;
    this.interval = 1;
    this.selectedDay = [];
    this.hourValue = null;
    this.minutValue = null;
    this.resetSelection.next();
    this.isValidData.next(false);
  }

  private filterOptions() {
    if (!this.jobTypes) {
      return;
    }
    // get the search keyword
    let search = this.filterCtrl.value;

    this.jobTypes = search
      ? this.initialOptions.filter((option) => {
          var key = this.translateService.instant(option.messageKey);
          return key.toLowerCase().indexOf(search.toLowerCase()) > -1;
        })
      : this.initialOptions.slice();
  }

  public validateDayOfMonth() {
    var max = parseInt(MAX_MONTH_DAYS);

    if (parseInt(this.monthDay) < 1) {
      this.monthDay = 1;
    }

    if (parseInt(this.monthDay) > max) {
      this.monthDay = max;
    }

    this.checkValidInputs();
  }

  public validateHours() {
    this.hourValue = UtilService.validateTime(
      this.hourValue,
      MIN_VALUE,
      MAX_HOURS
    );
    this.checkValidInputs();
  }

  public validateMinutes() {
    this.minutValue = UtilService.validateTime(
      this.minutValue,
      MIN_VALUE,
      MAX_MINUTES
    );
    this.checkValidInputs();
  }

  private getTime(): string {
    if (this.hourValue || this.minutValue) {
      return (
        UtilService.formatTime(+this.hourValue) +
        ":" +
        UtilService.formatTime(+this.minutValue)
      );
    }
    return null;
  }

  public onChangeInput(event) {
    alert(event);
  }
}