import { OnInit, Component, Input, NgZone } from "@angular/core";
import { MainPageService } from "../../main-page.service";
import { StpConfigureService } from "../stp-configure.service";
import { ShowViewerArgs } from "../../../models/viewer/ShowViewerArgs.model";
import { PipeRingVariantConfigModel } from "../../../models/parts/pipering-variant-config.model";

@Component({
    selector: 'threaded-configure',
    templateUrl: './threaded-configure.component.html',
    styleUrls: ['./threaded-configure.component.scss', '../stp-configure.component.scss']
})

export class ThreadedConfigureComponent implements OnInit {
    @Input() args: ShowViewerArgs = {
        variantId: "31",
        show: true,
        itemType: "PIPE_RING",
        itemId: "31",
        subType: null
    };
    private pipering: any[];
    public connectorOptions: any[];
    public channelOptions: any[];
    public currentChoosenThreadeRod: number = 1;
    public piperingVariantConfig: any;
    public selectedOption: any;

    @Input() set Args(value: ShowViewerArgs) {
        this.args = value;
        if (this.args !== null) {
            this.loadVariantData();
        }
    }

    constructor(private mainPageService: MainPageService,
        private stpConfigureService: StpConfigureService,
        private zone: NgZone
    ) {
        this.piperingVariantConfig = { threadedRods: [{ connectors: [] }] };
    }

    ngOnInit(): void {
        this.connectorOptions = [];
        this.loadVariantData();
        this.mainPageService.loadAllConnectors().subscribe((allConnectors) => {
            this.connectorOptions.splice(0, this.connectorOptions.length); // clear array
            for (var j = 0; j < allConnectors.length; j++) {
                var connector = allConnectors[j];
                this.connectorOptions.push({ id: connector._id, text: connector.name });
            }
        });
        this.mainPageService.loadAllChannels().subscribe((allChannels) => {
            this.channelOptions = allChannels;
        })
    }

    loadVariantData(): void {
        this.mainPageService.getPiperingVariantConfigurationData(this.args.variantId).subscribe((response) => {
            if ((response.isEmpty !== undefined) ? response.isEmpty : false) {
                this.createNewConfig();
            } else {
                this.piperingVariantConfig = response;
            }
        });
    }

    createNewConfig() {
        this.mainPageService.getSpecificPipering(this.args.itemId).subscribe((res) => {
            this.pipering = res;
            this.piperingVariantConfig = new PipeRingVariantConfigModel();
            this.piperingVariantConfig._id = this.args.variantId;
            this.piperingVariantConfig.isStandard = !(this.pipering[0].piperingGroupId === 2 || this.pipering[0].piperingGroupId === 3);
            if (this.piperingVariantConfig.isStandard) {
                this.piperingVariantConfig.isCeiling = true;
            }
            this.piperingVariantConfig.isDouble = false;
        });

    }

    saveVariantChanges() {
        this.mainPageService.postPiperingVariantConfiguration(this.piperingVariantConfig).subscribe((response) => { });
    }

    addConnector() {

        const emptyConnector = {
            id: (this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors !== undefined) ?
                this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors.length : 0,
            connectorId: null,
            connectorName: null,
            isShown: false,
        }
        this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors.push(emptyConnector);
        this.saveVariantChanges();
    }

    removeConnector(connector) {
        let newConnectors: any[] = [];
        for (let j = 0; j < this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors.length; j++) {
            const curConnector = this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors[j];
            if (curConnector !== connector) {
                const newThreadedRod = {
                    id: newConnectors.length + 1,
                    connectorId: curConnector.connectorId,
                    connectorName: curConnector.connectorName,
                    isShown: curConnector.isShown,
                };
                newConnectors.push(newThreadedRod);
            }
        }
        this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors = newConnectors;
        this.saveVariantChanges();
    }

    connectorChanged(connector, event) {
        const ind = this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors.indexOf(connector);
        this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors[ind].connectorId = event.id;
        this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1].connectors[ind].connectorName = event.text;
        this.saveVariantChanges();
    }

    // showConnector(arm, connector) {
    //     this.extensionInterface.changeShownconnector(arm, connector, this.currentChoosenThreadeRod);
    // }

    // hideConnectors() {
    //     this.extensionInterface.hideConnectorconnectors();
    // }

    addNewThreadedRod() {
        const emptyRod = {
            id: this.piperingVariantConfig.threadedRods.length + 1,
            channelId: this.selectedOption._id,
            channelName: this.selectedOption.name,
            connectors: [],
        }
        this.piperingVariantConfig.threadedRods.push(emptyRod);
        this.currentChoosenThreadeRod = this.piperingVariantConfig.threadedRods.length;
        this.saveVariantChanges();
    }

    removeCurrentThreadedRod() {
        let newThreadedRods: any[] = [];
        for (let j = 0; j < this.piperingVariantConfig.threadedRods.length; j++) {
            const curThreadedRod = this.piperingVariantConfig.threadedRods[j];
            if (curThreadedRod.id !== this.currentChoosenThreadeRod) {
                const newThreadedRod = {
                    id: newThreadedRods.length + 1,
                    _id: curThreadedRod.threadedRodName._id,
                    threadedRodName: curThreadedRod.threadedRodName,
                    connectors: curThreadedRod.connectors,
                }
                newThreadedRods.push(newThreadedRod);
            }
        }
        this.piperingVariantConfig.threadedRods = newThreadedRods;
        this.saveVariantChanges();
        if (this.piperingVariantConfig.threadedRods[this.currentChoosenThreadeRod - 1] === undefined) {
            this.currentChoosenThreadeRod = this.currentChoosenThreadeRod - 1;
        }
    }

    onGroupChange(event) {
        // this.showProfilesConfiguration();
    }

    activeConnector(connector) {
        const activeConnector = {
            id: connector.connectorId,
            text: connector.connectorName
        };
        const array = [];
        array.push(activeConnector);
        if (activeConnector.id !== null && activeConnector.text !== null) {
            return array;
        }
    }
}