import {SimpleTypeManifest, ArrayIterator, typeDef, Assert, G, IIterator, SContextError} from '../src/index' 

class TestObjectX  {

    x:string = "default-x";
     
}

class TestObjectY  {

    y:string = "default-y";
     
}


class TestObjectZ {

    z:string = "default-z";
     
}


class Person  {
    firstName:string;
    typeName:string =  "Person";
    lastName:string;
    constructor() {
        this.firstName = "testFirstName";
    }
}




//import SimpleTypeManifest from  '../src/org/subalternproductions/seepResource/dsl/manifest/SimpleTypeManifest'

//test("Basic typeDef ", () => {
   
    describe("a SimpleTypeManifest ", () => {

        var xdef:typeDef = {typeName:"TestObjectX", cls:TestObjectX};
        var ydef:typeDef = {typeName:"TestObjectY", cls:TestObjectY};
        var zdef:typeDef = {typeName:"TestObjectZ", cls:TestObjectZ};

        it("can instantiate objects", () => {
            var tdef1:typeDef = {typeName:"Person",  cls:Person }
            var tdef2:typeDef = {typeName:"Person2", create: () => {var o = new Person; o.lastName = "create-2"; return o}}
            
            
            var p1:Person = G.createType(tdef1)
            expect(p1 instanceof Person ).toBe(true)

            var p2:Person = G.createType(tdef2);
            expect(p2 instanceof Person).toBe(true)
            expect(p2.lastName).toBe("create-2")

        } );

        it("creates objects from Manifest", () => {

            var xdef:typeDef = {typeName:"TestObjectX", cls:TestObjectX};
            var ydef:typeDef = {typeName:"TestObjectY", cls:TestObjectY};
            var manifest  = new SimpleTypeManifest([xdef, ydef]);

            var xout:any = manifest.createType("TestObjectX");
            expect(xout instanceof TestObjectX).toBe(true);

            expect(xout.x).toBe("default-x");
            
            var xout:any = manifest.createType("TestObjectY")
            expect(xout instanceof TestObjectY).toBe(true);
            expect(xout.y).toBe("default-y");


        });

        it("iterates type contents", () => {
            var manifest  = new SimpleTypeManifest([xdef, ydef]);

            var it:IIterator<string> = manifest.iterator();
            var count = 0;
            var allTypes:Array<string> = [];
            while (it.hasNext()) {
                count++
                var type:string = it.next();
                allTypes.push(type)
            }

            expect(count).toBe(2);
            expect(allTypes).toEqual( ["TestObjectX","TestObjectY" ]);
        })
        
        it("recurses to parent a manifest", ()=> {
            var manifest = new SimpleTypeManifest()
            var manifestParent = new SimpleTypeManifest();
            var manifestGrandParent = new SimpleTypeManifest()

            manifest.types = [xdef]
            manifestParent.types = [ydef]
            manifestGrandParent.types = [zdef]

            manifestParent.init(manifestGrandParent);

            var z0 = manifestGrandParent.createType("TestObjectZ");
            expect(z0 instanceof TestObjectZ).toBe(true)

            manifest.init(manifestParent);
            
            var x1 = manifest.createType("TestObjectX");
            var y1 = manifest.createType("TestObjectY");
            var z1 = manifest.createType("TestObjectZ")
            expect(x1 instanceof TestObjectX).toBe(true)
            expect(y1 instanceof TestObjectY).toBe(true)
            expect(z1 instanceof TestObjectZ).toBe(true)


        })

        it("crashes on duplicate defs", ()=>{
           
            expect( () => {
                    var manifest    = new SimpleTypeManifest([xdef, xdef]) 
             }
            ).toThrow( "duplicate type def TestObjectX") //, "duplicate type def TestObjectX");



        })




    });


//})