module fb {
    // Klass som har funktioner som overridas med standard Array-funktioner för att kunna ärva ner dom till List-klassen
    export class fbArray<T> {
        constructor() {
            //super();
            Array.apply(this, arguments);
            return new Array();
        }
        pop(): T { throw 'Fel funktion i fbArray (fbList)'; }
        push(val: T): number { throw 'Fel funktion i fbArray (fbList)';}
        length: number;
        //concat<U extends T[]>(...items: U[]): T[] { return [];}
        //concat(...items: T[]): T[] { return [];}
        reverse(): T[] { throw 'Fel funktion i fbArray (fbList)'; }
        shift(): T { throw 'Fel funktion i fbArray (fbList)'; }
        slice(start?: number, end?: number): T[] { throw 'Fel funktion i fbArray (fbList)'; }
        sort(compareFn?: (a: T, b: T) => number): this { throw 'Fel funktion i fbArray (fbList)'; }
        splice(start: number, deleteCount: number, ...items: T[]): T[] { throw 'Fel funktion i fbArray (fbList)'; }
        unshift(...items: T[]): number { throw 'Fel funktion i fbArray (fbList)'; }
        indexOf(searchElement: T, fromIndex?: number): number { throw 'Fel funktion i fbArray (fbList)'; }
        lastIndexOf(searchElement: T, fromIndex?: number): number { throw 'Fel funktion i fbArray (fbList)'; }
    }

    fbArray["prototype"] = new Array();

    export class List<T> extends fbArray<T> {
        $promise: ng.IPromise<T[]>;
        $resolved: boolean;
        $failed: boolean;
        [num: number]: T;
        constructor(data: any, type?: any) {
            super();

            // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
            (Object as any).setPrototypeOf(this, List.prototype);

            //var self = this;
            if (data.$promise) {
                this.$promise = data.$promise;
                this.$promise.then((res) => {
                    this.init(res, type);
                    this.$resolved = true;
                },  (error) => {
                        this.$failed = true;
                    });
            } else {
                this.init(data, type);

                var def;
                if (angular.element(document).injector()) {
                    def = angular.element(document).injector().get('$q').defer();
                } else {
                    var $injector = angular.injector(['ng']);
                    $injector.invoke(['$q', function ($q: ng.IQService) {
                        def = $q.defer();
                    }]);
                }

                this.$promise = def.promise;
                def.resolve(data);
                this.$resolved = true;
            }
        }
        init(initData: T[], type?: any) {
            var self: any = this;
            if (!(initData instanceof Array)) {
                throw 'Försökte skapa en lista med icke array-data';
            }
            //if (!type) {
            //    throw 'Fanns ingen type, glömt att lägga till modellen i index.html'
            //}
            for (var i: number = 0; i < initData.length; i++) {
                if (type) {
                    self.push(new type(initData[i]));
                } else {
                    self.push(initData[i]);
                }
            }
            Array.apply(this, initData);
        }
        toArray(): T[] {
            var self = this;
            var tmp = [];
            angular.forEach(self, function (value, key) {
                tmp.push(value);
            });
            return tmp;
        }
    }
}