import {AfterViewInit, ChangeDetectorRef, Component, OnInit, ViewChild} from '@angular/core';
import {MatSort, Sort, MatSortModule} from "@angular/material/sort";
import {MatTableDataSource, MatTableModule} from "@angular/material/table";
import {ActivatedRoute, Router, RouterLink, RouterLinkActive} from "@angular/router";
import {Subscription} from "rxjs";
import {PartnerJsonld, PartnerService} from "@app/core/api/v1";
import {MatPaginator, MatPaginatorIntl, MatPaginatorModule, PageEvent} from "@angular/material/paginator";
import {OrderFilter} from "@app/_models/orderFilter";
import {ApiHelperService} from "@app/_helpers/api-helper.service";
import {NgIf} from "@angular/common";
import {NgbModal, NgbModalOptions} from "@ng-bootstrap/ng-bootstrap";
import {NewPartnerComponent} from "@app/_views/partners/new-partner/new-partner.component";
import {TranslateModule, TranslateService} from "@ngx-translate/core";
import {ModalStatus} from "@app/_helpers/modal.states";
import TypeEnum = PartnerJsonld.PartnerTypeEnum;

@Component({
    selector: 'app-partners',
    templateUrl: './partners.component.html',
    styleUrl: './partners.component.scss',
    standalone: true,
    imports: [MatTableModule, MatSortModule, MatPaginatorModule, RouterLink, RouterLinkActive, NgIf, TranslateModule],
})
export class PartnersComponent implements OnInit, AfterViewInit {
    @ViewChild(MatSort) partnersSort;
    @ViewChild(MatPaginator) partnersPaginator: MatPaginator;

    protected partnersSub: Subscription;
    protected partners: Array<PartnerJsonld>;

    protected nameOrderAsc: OrderFilter;
    protected cityOrderAsc: OrderFilter;
    protected websiteOrderAsc: OrderFilter;

    protected dataType!: string;
    protected headline: string;
    protected partnerNameOne: string;
    protected displayedColumns: string[];

    protected partnersDataSource;
    protected partnersLength: number;
    protected partnersPageEvent: PageEvent;
    protected partnersPageSize: number;
    protected partnersPageIndex: number;

    protected modalOptions: NgbModalOptions = {
        centered: true
    };

    constructor(
        private route: ActivatedRoute,
        private partnerService: PartnerService,
        private router: Router,
        private modalService: NgbModal,
        private translateService: TranslateService,
        protected apiHelperService: ApiHelperService,
    ) {
        this.partnersSort = new MatSort();
        this.partnersPaginator = new MatPaginator(new MatPaginatorIntl(), ChangeDetectorRef.prototype);

        this.partnersSub = new Subscription();
        this.partners = [];
        this.displayedColumns = ['pos', 'image', 'name', 'address', 'website'];

        this.nameOrderAsc = OrderFilter.Asc;
        this.cityOrderAsc = OrderFilter.Asc;
        this.websiteOrderAsc = OrderFilter.Asc;

        this.partnersDataSource = new MatTableDataSource<PartnerJsonld>(this.partners);
        this.partnersLength = 0;
        this.partnersPageEvent = new PageEvent();
        this.partnersPageSize = 10;
        this.partnersPageIndex = 0;

        this.headline = "";
        this.partnerNameOne = "";
    }

    ngOnInit() {
        this.dataType = this.route.snapshot.data['dataType'];
        // this.translateService.use(this.translateService.getDefaultLang());
        this.translateService.get('basic.' + this.dataType).subscribe((translation: string) => {
            this.headline = translation;
        });
        this.translateService.get('basic.' + this.dataType + 'One').subscribe((translation: string) => {
            this.partnerNameOne = translation;
        });
        this.getPartnersData();
    }

    ngAfterViewInit() {
        this.partnersDataSource.sort = this.partnersSort;
        this.partnersDataSource.paginator = this.partnersPaginator;
    }

    getPartnersData() {
        this.partnersSub = this.partnerService.partnersGetCollection(
            this.partnersPageIndex + 1,
            this.partnersPageSize,
            this.dataType,
            undefined,
            undefined,
            this.nameOrderAsc,
            this.cityOrderAsc,
            this.websiteOrderAsc
        ).subscribe(
            data => {
                this.partners = data["hydra:member"];
                this.partnersDataSource = new MatTableDataSource<PartnerJsonld>(this.partners);
                this.partnersLength = Number(data["hydra:totalItems"]);
                this.partnersPaginator.length = this.partnersLength;
            }
        );
        // switch over this.dataType (customers, etc.)
    }

    /** Announce the change in sort state for assistive technology. */
    onSortChange(sortState: Sort) {
        // Reset page index to first page
        this.partnersPageIndex = 0;

        let order: OrderFilter;
        if (sortState.direction === "") {
            order = OrderFilter.Undefined;
        } else {
            order = sortState.direction;
        }

        this.nameOrderAsc = OrderFilter.Undefined;
        this.cityOrderAsc = OrderFilter.Undefined;
        this.websiteOrderAsc = OrderFilter.Undefined;
        switch (sortState.active) {
            case "name":
                this.nameOrderAsc = order;
                break;
            case "address":
                this.cityOrderAsc = order;
                break;
            case "website":
                this.websiteOrderAsc = order;
                break;
        }
        this.getPartnersData();
    }

    handlePageEvent(e: PageEvent) {
        this.partnersPageEvent = e;
        this.partnersLength = e.length;
        this.partnersPageIndex = e.pageIndex.valueOf();
        this.partnersPageSize = e.pageSize.valueOf();
        this.getPartnersData();
    }

    navigateToPartnerDetails(element: any) {
        const partner: PartnerJsonld = element as PartnerJsonld;
        this.router.navigate(['/' + partner.partnerType, this.apiHelperService.extractId(partner.id)]);
    }

    openModalNewPartner() {
        const modalRefContact = this.modalService.open(NewPartnerComponent, this.modalOptions);
        let partner: PartnerJsonld = {} as PartnerJsonld;
        partner.partnerType = this.dataType as TypeEnum;
        modalRefContact.componentInstance.partner = partner;
        modalRefContact.componentInstance.submit.subscribe((modalStatus: ModalStatus) => {
            if (modalStatus === ModalStatus.Submitted) {
                modalRefContact.dismiss();
                this.getPartnersData();
            }
        });
    }
}