/*--------------------------------------------------------------------------------------------------------------
 *  Copyright (c) insite-gmbh. All rights reserved.
 *  Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------------------------*/
import { Observable } from 'rxjs/Rx';
import { Injectable } from '@angular/core';
import { Http, Headers } from '@angular/http';
import { InaxConfiguration} from '../../../@inax/common';
import { InaxLoggerService } from '../../../@inax/logger';
import { InaxTranslateService } from '../../../@inax/translate';
import { Subject } from "rxjs/Subject";
import { IMotionEx, IFinalPositionEx, MotionTextTable, LanguageEntryList } from './domain';

//TODO:Test if it is better to use pipes for translation
@Injectable()
export class InaxMotionTextsService {
    private _tableName: string = "Motions";
    private _tableQuery: string = "BlockNum = {}";
    private _defaultLanguage: string;
    private _language:string;

    constructor(
        private _logger: InaxLoggerService,
        private _translate: InaxTranslateService,
        private _configuration:InaxConfiguration) {

        this._defaultLanguage = this._configuration.DefaultLanguage;
    }

    public getSymbolicName(motion:IMotionEx):string{
        let textList = this.getTextTable(motion);
        return textList.get(motion.Name);
    }

    public getDirection1Text(motion:IMotionEx):string{
        let textList = this.getTextTable(motion);
        return textList.get(motion.Direction1Text);
    }

    public getDirection2Text(motion:IMotionEx):string{
        let textList = this.getTextTable(motion);
        return textList.get(motion.Direction2Text);
    }

    public getFinalPositionText(motion:IMotionEx, finalPosition:IFinalPositionEx):string{
        let textList = this.getTextTable(motion);
        return this.getPositionTextsByUsageType(finalPosition,textList);
    }

    private getTextTable(motion:IMotionEx):LanguageEntryList{
        if(motion.Texts == null || !motion.Texts.hasLanguage(this._language)){
            this.loadTextsForMotion(motion);
            return motion.Texts.Language[this._defaultLanguage];
        }
        return motion.Texts.Language[this._language];
    }

    private loadTextsForMotion(motion:IMotionEx){
        this.loadDefaultTexts(motion);
        if(this._language != this._defaultLanguage)
            this.loadLanguageTexts(motion);
    }

    private getPositionTextsByUsageType(finalPosition: IFinalPositionEx, texts:LanguageEntryList):string {
        switch (finalPosition.UsageType) {
            case 0: //not in use
                return "";
            case 1: //free text
                return texts.get(finalPosition.Name);
            case 2: //auto text
            case 3: //auto operand
                return texts.get(finalPosition.SymbolicAddress);
            case 4: //editable bit
            case 5: //editable operand
                return texts.get(finalPosition.Name);
        }
    }

    private async loadLanguageTexts(motion: IMotionEx){
        if(!motion.Texts.hasLanguage(this._language))
           motion.Texts.Language[this._language] = new LanguageEntryList()
        {
            let toTranslate = motion.Texts.Language[this._defaultLanguage].keys;
            let translated = await this._translate.tranlsateManyOnline(toTranslate,this._defaultLanguage, this._language).toPromise(); 
            let txt: LanguageEntryList = motion.Texts.Language[this._language];
            for(let i = 0; i < translated.length; i++){
                txt.add(toTranslate[i], translated[i]);
            }                             
        }
    }

    private loadDefaultTexts(motion: IMotionEx) {
        if (motion.Texts == null) {
            motion.Texts = new MotionTextTable();
            let txt: LanguageEntryList = new LanguageEntryList();

            txt.add(motion.Name, motion.Name);
            txt.add(motion.Direction1Text, motion.Direction1Text);
            txt.add(motion.Direction2Text, motion.Direction2Text);

            motion.FinalPositions.forEach(finalPosition => {
                if (txt.get(finalPosition.SymbolicAddress) == null) {
                    switch (finalPosition.UsageType) {
                        case 0: //not in use
                            break;
                        case 1: //free text
                            if (finalPosition.Name != null)
                                txt.add(finalPosition.Name,finalPosition.Name);
                            break;
                        case 2: //auto text
                        case 3: //auto operand
                            if (finalPosition.SymbolicAddress != null)
                                txt.add(finalPosition.SymbolicAddress,finalPosition.SymbolicAddress);
                            break;
                        case 4: //editable bit
                        case 5: //editable operand
                            if (finalPosition.Name != null)
                                txt.add(finalPosition.Name,finalPosition.Name);
                            break;
                    }
                }
            });

            motion.Texts.Language[this._defaultLanguage] = txt;
        }
    }
}