import {
    Component,
    EventEmitter,
    Input,
    OnChanges,
    Output,
    SimpleChanges,
    ViewEncapsulation
} from '@angular/core';
import { YEARS, OPTS } from '../../constants/constants';
import { UtilService } from '../../services/public-api';
import {
    IMyCalendarYear,
    IMyOptions,
    IMyDate,
    IMyDateRange
} from '../../interfaces/public-api';
import { KeyCode } from '../../enums/public-api';

@Component({
    selector: 'lib-year-view',
    templateUrl: './year-view.component.html',
    providers: [UtilService],
    encapsulation: ViewEncapsulation.None
})
export class YearViewComponent implements OnChanges {
    @Input() opts: IMyOptions;
    @Input() years: Array<Array<IMyCalendarYear>>;
    @Input() prevViewDisabled: boolean;
    @Input() nextViewDisabled: boolean;
    @Input() selectedDate: IMyDate;
    @Input() selectedDateRange: IMyDateRange;

    @Output() yearCellClicked: EventEmitter<IMyCalendarYear> = new EventEmitter<
        IMyCalendarYear
    >();
    @Output() yearCellKeyDown: EventEmitter<IMyCalendarYear> = new EventEmitter<
        IMyCalendarYear
    >();
    @Output() prevCellClicked: EventEmitter<void> = new EventEmitter<void>();
    @Output() nextCellClicked: EventEmitter<void> = new EventEmitter<void>();

    @Output() onMouseEnter: EventEmitter<any> = new EventEmitter<any>();
    @Output() onMouseLeave: EventEmitter<any> = new EventEmitter<any>();

    constructor(private utilService: UtilService) {}
    ngOnInit(): void {}
    ngOnChanges(changes: SimpleChanges): void {
        if (changes.hasOwnProperty(OPTS)) {
            this.opts = changes[OPTS].currentValue;
        }
        if (changes.hasOwnProperty(YEARS)) {
            this.years = changes[YEARS].currentValue;
        }
    }

    onYearCellClicked(event: any, cell: IMyCalendarYear): void {
        event.stopPropagation();
        if (cell.disabled) {
            return;
        }
        this.yearCellClicked.emit(cell);
    }

    onYearCellKeyDown(event: KeyboardEvent, cell: IMyCalendarYear) {
        const keyCode: number = this.utilService.getKeyCodeFromEvent(event);
        if (keyCode !== KeyCode.tab) {
            event.preventDefault();

            if (keyCode === KeyCode.enter || keyCode === KeyCode.space) {
                this.onYearCellClicked(event, cell);
            } else if (this.opts.moveFocusByArrowKeys) {
                this.yearCellKeyDown.emit(cell);
            }
        }
    }
    onPrevOrNextYearCellClicked(event: any, index: number) {
        event.stopPropagation();
        if (index === 0) {
            if (this.prevViewDisabled) return;
            this.prevCellClicked.emit(event);
        } else {
            if (this.nextViewDisabled) return;
            this.nextCellClicked.emit(event);
        }
    }
    onMonthCellMouseEnter(cell: any): void {
        if (
            this.utilService.isInitializedDate(this.selectedDateRange.begin) &&
            !this.utilService.isInitializedDate(this.selectedDateRange.end)
        ) {
            for (let i = 0; i < this.years.length; i++) {
                let row = this.years[i];
                for (let j = 0; j < row.length; j++) {
                    let year = row[j];
                    year.range =
                        (this.utilService.isDateSameOrEarlier(
                            this.selectedDateRange.begin,
                            year.yearObj
                        ) &&
                            this.utilService.isDateSameOrEarlier(
                                year.yearObj,
                                cell.yearObj
                            )) ||
                        (this.utilService.isDateSameOrEarlier(
                            year.yearObj,
                            this.selectedDateRange.begin
                        ) &&
                            this.utilService.isDateSameOrEarlier(
                                cell.yearObj,
                                year.yearObj
                            ));
                }
            }
            this.onMouseEnter.emit(cell);
        }
    }

    onMonthCellMouseLeave(): void {
        for (let i = 0; i < this.years.length; i++) {
            let row = this.years[i];
            for (let j = 0; j < row.length; j++) {
                let year = row[j];
                year.range = false;
            }
        }
        this.onMouseLeave.emit();
    }
    isMonthInRange(year: IMyDate): boolean {
        return this.utilService.isDateInRange(year, this.selectedDateRange);
    }
    isMonthSame(year: IMyDate): boolean {
        return this.utilService.isDateSame(
            {
                year: this.selectedDate.year
            },
            year
        );
    }
    isMonthRangeBeginOrEndSame(year: IMyDate): boolean {
        return this.utilService.isDateSame(
            { year: this.selectedDateRange.begin.year }, year
        ) || this.utilService.isDateSame(
            { year: this.selectedDateRange.end.year }, year
        );
    }
}