//****** EXTERNAL PACKAGE IMPORTS ******
require('reflect-metadata');
import * as assert from 'assert';
import 'mocha';
//import assert = require("assert");
import { Http, Headers, RequestOptions, Connection, ConnectionBackend } from '@angular/http';
import { Injectable, Inject, Provider } from '@angular/core';
import rxSubject = require("rxjs/Subject");
import { Observable } from 'rxjs/Rx';

//import 'jsdom-global/register';
//import TypeMoq = require('typemoq');
//let ServerMock = require('mock-http-server');
//require('jsdom-global')();
//let mockBrowser = require('mock-browser').mocks.MockBrowser;

//*********** LOCAL IMPORTS ***********
import dCE = require("../src/domain/dataChangedEvent");
import pM = require("../src/domain/plcMapping");
import conv = require("../src/converter");
import { InaxPlcService } from '../src/plc';
import plcAbs = require("../src/domain/plcAbs");

//*********** COMMON IMPORTS ***********
import { InaxSignalR, IHubService, SignalrWindow, ConnectionState } from '../../common/src/signalR';
import { ProfileService } from '../../common/src/serviceAuthentication/profile.service';
import { InaxConfiguration } from '../../common/src/inaxConfiguration';
import { ServiceAuthentication } from '../../common/src/serviceAuthentication/serviceAuthentication';

//import { Configuration, ProfileService, InaxSignalR, ConnectionState, IHubService, SignalrWindow} from '../../../@inax/common';
//import { InaxSignalR, SignalrWindow, ConnectionState } from './mockClasses/mockSignalR';
//import { TestClass, MockWindow, Window, InaxPlcService } from './mockClasses/mockPlc';


//**********************************************************************
//*                         IMPORT MOCK-CLASSES                        *
//**********************************************************************
import { mockHubCon } from './mockClasses/mockHubCon'; //mocks a hubConnection
import { MyHubService } from './mockClasses/mockSignalRServices'; //example class to implement IHubService interface
import { myConnection, mockConnectionBackend } from './mockClasses/mockHttp'; //example classes to implement abstract connection classes
//import { MyWindow } from './mockClasses/mockWindow';

describe('plc/', function () {
    describe('\bdomain/', function () {
        describe('\bplcAbs.ts           ', function () {
            let testINAX: plcAbs.PlcAbs;
            it('throw error on invalid Address or Address parts', function (done) {
                //this.expected = 20;
                let getSel = testINAX.getINAXSelector;
                let exType = testINAX.extractINAXType;
                let badSelectorAddress = 'WX3.5';
                let badTypeAddress = 'BOOLEAM25.1';
                let badPointerTypeAddress = '42.1S5TIMEE6';
                let illegalCharacterAddress = 'STRING23.2W';
                let lengthTooBigAddress = 'STRING15.8';
                let badDBSelectorAddress = 'DB23A.DB';
                assert.throws(() => { getSel(badSelectorAddress, 'DE') }, 'detect invalid Selector');
                assert.throws(() => { getSel(badDBSelectorAddress, 'DE') }, 'detect invalid DB Selector');
                assert.throws(() => { exType(badTypeAddress) }, 'detect invalid Type');
                assert.throws(() => { exType(illegalCharacterAddress) }, 'detect illegal characters');
                assert.throws(() => { exType(badPointerTypeAddress) }, 'detect bad Type in pointer format address');
                assert.throws(() => { testINAX.getINAXNumericValues(lengthTooBigAddress) }, 'throw out of range error on bitoffset > 7');
                done();
            });
            it('convert absAddress to INAX (DB Selector)', function () {
                let testDB = 'DB1180';
                let testType = 'X'; //only bool or string, else remove ['.'+testLength] from Address
                let testOffset = 136;
                let testLength = 4;
                let testAddress = testType + testOffset + '_' + testLength;
                let testDBAddress = testDB + '.DB' + testType + testOffset + '.' + testLength;
                testINAX = plcAbs.PlcAbs.toINAX(testDBAddress, 'EN');
                assert.deepStrictEqual(testINAX.getSelector(), testDB, 'get database selector');
                assert.deepStrictEqual(testINAX.getType(), testType, 'get Type');
                assert.deepStrictEqual(testINAX.getOffset(), testOffset, 'get Offset');
                assert.deepStrictEqual(testINAX.getLength(), testLength, 'get Length');
                assert.deepStrictEqual(testINAX.getAddress(), testAddress, 'get Address');
                assert.deepStrictEqual(testINAX.getMnemonic(), 'EN', 'get Mnemonic');
            });
            it('mnemonics work as expected', function () {
                assert.deepStrictEqual(plcAbs.PlcAbs.toINAX('EB120', 'DE').getSelector(), plcAbs.PlcAbs.toINAX('IB120', 'EN').getSelector(), 'compare selector "E" in German and "I" in English environment');
                assert.deepStrictEqual(plcAbs.PlcAbs.toINAX('AB120').getSelector(), plcAbs.PlcAbs.toINAX('QB120', 'EN').getSelector(), 'compare selector "A" in German and "Q" in English environment and setting "DE" as default mnemonic');
                assert.deepStrictEqual(plcAbs.PlcAbs.toINAX('ZB120', 'DE').getSelector(), plcAbs.PlcAbs.toINAX('CB120', 'EN').getSelector(), 'compare selector "Z" in German and "C" in English environment');
            });
            it('convert back to absAddress', function () {
                assert.deepStrictEqual(plcAbs.PlcAbs.toINAX('DB9999.DBSTRING42.7').toPLC(), 'DB9999.DBS42.7');
                assert.deepStrictEqual(plcAbs.PlcAbs.toINAX('E152.6').toPLC('EN'), 'IX152.6', 'tests mnemonic for toPLC and setting X as type if none is specified');
                assert.deepStrictEqual(plcAbs.PlcAbs.toINAX('EBOOL152.5').toPLC(), 'EX152.5', 'tests default mnemonic for toPLC');
            });
            testINAX = new plcAbs.PlcAbs;
            it('convert Pointer Address to INAX', function () {
                let testS7A = 'P# DB10.DBX 133.7 S5TIME 9';
                testINAX = plcAbs.PlcAbs.toINAX(testS7A);
                assert.deepStrictEqual(testINAX.getAddress(), 'S5TIME133_7', 'get Address');
                assert.deepStrictEqual(testINAX.getCountOfData(), 9, 'get CountOfData');
            });
            it('test mnemonics for pointer format', function () {
                let testS7A = 'P# A 9.2 BOOL 5';
                testINAX = plcAbs.PlcAbs.toINAX(testS7A);
                assert.deepStrictEqual(testINAX.getAddress(), 'X9_2', 'get Address and test "EN" mnemonic in pointer format');
            });
            it('convert back to pointer format Address', function () {
                assert.deepStrictEqual(testINAX.toPLC('EN'), 'P# Q 9.2 X 5', 'test toPLC(mnemonic) for pointer format');
                assert.deepStrictEqual(testINAX.toPLC(), 'P# A 9.2 X 5', 'test toPLC() for pointer format (default mnemonic)');
            });
        });
        describe('\bdataChangedEvent.ts ', function () {
            let testEvent = new dCE.DataChangeEvent;
            it('add properties', function (done) {
                testEvent.Group = "Group assigned";
                testEvent.Mapping = "Mapping assigned";
                testEvent.Data = [123, "Data assigned"];
                done();
            });
            it('call properties', function () {
                assert.notEqual(testEvent.Timestamp, undefined);
                assert.deepStrictEqual(testEvent.Group, "Group assigned");
                assert.deepStrictEqual(testEvent.Mapping, "Mapping assigned");
                assert.deepStrictEqual(testEvent.Data[1], "Data assigned");
            });
        });

        describe('\bplcMapping.ts       ', function () {
            it('IPlcMappingPack: properties can be assigned', function (done) {
                let testMappingPack = new pM.PlcMappingPack;
                testMappingPack.Variable = "variable";
                testMappingPack.Type = "type";
                testMappingPack.Selector = "selector";
                testMappingPack.Offset = 1;
                testMappingPack.ObservationRate = 1;
                done();
            });
        });

        // would not work anymore, because only the factory could create the Proxy!!!!
        // describe('\bsubscriber.ts       ', function () {
        //     let subscriber = new pS.PlcSubscriber((inst) => { });
        //     it('PlcSubscriber: trivial properties can be assigned', function () {
        //         subscriber.Group = "Group";
        //         subscriber.Mapping = "Mapping";
        //         subscriber.Variables = "variables";
        //     });
        //     it('create Subject', function () {
        //         let subjectDest;
        //         let subjectSrc;
        //         subscriber.Subject = new rxSubject.Subject<dCE.DataChangeEvent>(subjectDest, subjectSrc);
        //     });
        // });
    });


    describe('\bconverter.ts               ', function () {
        describe('base64ToArray', function () {
            let enc = conv.Converter.enc_btoa("extended test string with special chars: 1234567890; Ä##+!§$%&/((=?´´)--_.,~@€µ<>|\\ß[]^°");
            it('decodes base-64 encoded string', function () {
                //console.log(enc);
                assert.notEqual(conv.Converter.base64ToArray(enc), undefined);
            });
        });

        describe('objectToArray', function () {
            let myObject = {
                mytest1: "testtesttesttesttesttest",
                mytest2: {
                    prop21: "two",
                    myArray: ["test", "array", "123"]
                },
                mytest3: "asdasd"
            }
            let resultArray = conv.Converter.objectToArray(myObject, "my");
            it('converts to array', function (done) {
                if (Array.isArray(resultArray)) { done(); }
            });
            it('array content equals object content', function (done) {
                let isEqual = true;
                for (let prop in resultArray) {
                    if (resultArray[prop] !== myObject['my' + prop]) { isEqual = false; }
                }
                if (isEqual) { done(); }
            });
        });

        describe('getValue', function () {
            let getmyValue = conv.Converter.getValue;
            let myObject = {
                value0: "level0value",
                level1: {
                    value1: "level1value",
                    array1: [
                        "",
                        {
                            arraylevel1value: "aL1value",
                            level2array: ["test", { arraylevel2value: "aL2value" }]
                        },
                        [ 2, [ "hiddenValue" ] ]
                    ],
                    level2: {
                        value2: "level2value",
                        otherValue2: "otherlevel2Value"
                    }
                }
            }
            it('gets value from nested object with array', function () {
                assert.deepStrictEqual(getmyValue(myObject, "level1.array1[1].level2array[1].arraylevel2value"), "aL2value");
            });
            it('accepts default return value', function () {
                assert.deepStrictEqual(getmyValue(myObject, "level1.array1[5].test", 0), 0);
            });
            it('gets value from nested array', ()=>{
                assert.deepStrictEqual(getmyValue(myObject, "level1.array1[2][1][0]"), "hiddenValue");
            });
        });
    });
    
    describe('\bplc.ts                     ', function () {
        let mySignalRWindow: SignalrWindow, myHttp: Http, myConfig: InaxConfiguration, 
            myProfileService: ProfileService, myPlc: InaxPlcService, mySignalR: InaxSignalR;
        
        it('set auth_token in localStorage', (done)=>{//set token so ProfileService can be instantiated without giving a warning
            localStorage.setItem('auth_token', JSON.stringify(new ServiceAuthentication));
            done();
        });
        
        it('define examples for classes/create mock objects', (()=>{//inject([Window], (window: Window)=>{
            mySignalRWindow = new SignalrWindow();
            mySignalRWindow.$ = { hubConnection: ()=>{ return new mockHubCon(); }, signalR : { connectionState : ConnectionState } };
            myHttp = new Http(new mockConnectionBackend(), new RequestOptions());
            myConfig = new InaxConfiguration();
            myProfileService = new ProfileService(myHttp, myConfig);
            myPlc = new InaxPlcService(myHttp, myConfig, myProfileService);
            mySignalR = new InaxSignalR([new MyHubService()], myConfig, mySignalRWindow, myProfileService); 
        }));

        it('registerEvents', (done)=>{
            myPlc.registerEvents(mySignalR);
            done();
        });
        it('create subscriber proxy', (done)=>{
            myPlc.createEventProxy('group', 'id', 'map', []);
            done();
        });
        xit('readSingle', (done)=>{//implement http-GET first
            console.log(myPlc.readSingle('only', 'for', 'testing'));
            done();
        });
        
    });
});