import {
    AssociatedCollectionItem,
    Collection, CollectionIndex,
    CollectionItem, ComparisonFunction,
    DeterminesEquality, KeyFunction,
    KeyOperator, KeyReducerFunction, MaybeCollectionIndex, MaybeCollectionItem
} from './Collection.ts'
import {Iterable, StopIteration} from './Iterable.ts'
import {applyWhere, WhereOperator} from './Where.ts'
type AsyncCollectionComparable<T> = CollectionItem<T>[] | Collection<T> | AsyncCollection<T>
type AsyncKeyFunction<T, T2> = (item: CollectionItem<T>, index: number) => CollectionItem<T2> | Promise<CollectionItem<T2>>
type AsyncCollectionFunction<T, T2> = (items: AsyncCollection<T>) => T2

export class AsyncCollection<T> {
    constructor(
        private _items: Iterable<T>,
        private _chunk_size: number = 1000, // TODO fix this. It's just for testing
    ) {}

    private async _chunk(callback: (items: Collection<T>) => any): Promise<void> {
        await this._items.chunk(this._chunk_size, async items => {
            await callback(items)
        })
        await this._items.reset()
    }

    private async _chunk_all<T2>(key: KeyOperator<T, T2>, callback: (items: Collection<T2>) => any): Promise<void> {
        await this._items.chunk(this._chunk_size, async items => {
            await callback(items.pluck(key))
        })
        await this._items.reset()
    }

    private async _chunk_all_numbers<T2>(key: KeyOperator<T, T2>, callback: (items: number[]) => any): Promise<void> {
        await this._items.chunk(this._chunk_size, async items => {
            await callback(items.pluck(key).map(x => Number(x)).all())
        })
        await this._items.reset()
    }

    private async _chunk_all_associate<T2>(key: KeyOperator<T, T2>, callback: (items: AssociatedCollectionItem<T2, T>[]) => any): Promise<void> {
        await this._items.chunk(this._chunk_size, async items => {
            const assoc_items: AssociatedCollectionItem<T2, T>[] = []
            if ( typeof key === 'function' ) {
                items.map((item, index) => {
                    const key_item = key(item, index)
                    assoc_items.push({ key: key_item, item })
                })
            } else if ( typeof key === 'string' ) {
                items.map((item, index) => {
                    assoc_items.push({ key: (<any>item)[key], item })
                })
            }

            await callback(assoc_items)
        })
        await this._items.reset()
    }

    async all(): Promise<CollectionItem<T>[]> {
        return (await this._items.from_range(0, await this._items.count())).all()
    }

    async collect(): Promise<Collection<T>> {
        return this._items.from_range(0, await this._items.count())
    }

    async average<T2>(key?: KeyOperator<T, T2>): Promise<number> {
        let running_total = 0
        let running_items = 0

        const chunk_helper = (items: number[]) => {
            running_items += items.length
            running_total += items.reduce((prev, curr) => prev + curr)
        }

        if ( key ) await this._chunk_all_numbers(key, chunk_helper)
        else await this._chunk((items) => {
            chunk_helper(items.map(x => Number(x)).all())
        })

        return running_total / running_items
    }

    async median<T2>(key?: KeyOperator<T, T2>): Promise<number> {
        let items: number[] = []

        const chunk_helper = (next_items: number[]) => {
            items = items.concat(next_items)
        }

        if ( key ) await this._chunk_all_numbers(key, chunk_helper)
        else await this._chunk(items => {
            chunk_helper(items.map(x => Number(x)).all())
        })

        items = items.sort((a, b) => a - b)
        const middle = Math.floor((items.length - 1) / 2)
        if ( items.length % 2 ) return items[middle]
        else return (items[middle] + items[middle + 1]) / 2
    }

    async mode<T2>(key?: KeyOperator<T, T2>): Promise<number> {
        let counts: any = {}

        const chunk_helper = (items: number[]) => {
            for ( const item of items ) {
                if ( !counts[item] ) counts[item] = 1
                else counts[item] += 1
            }
        }

        if ( key ) await this._chunk_all_numbers(key, chunk_helper)
        else await this._chunk(items => {
            chunk_helper(items.map(x => Number(x)).all())
        })

        return Number(Object.keys(counts).reduce((a, b) => counts[a] > counts[b] ? a : b)[0])
    }

    async collapse(): Promise<Collection<any>> {
        const items = await this.collect()
        return items.collapse() as Collection<any>
    }

    async contains<T2>(key: KeyOperator<T, T2>, operator: WhereOperator, operand?: any): Promise<boolean> {
        let contains = false

        await this._chunk_all_associate(key, (items: AssociatedCollectionItem<T2, T>[]) => {
            const matches = applyWhere(items, operator, operand)
            if ( matches.length > 0 ) {
                contains = true
                throw new StopIteration()
            }
        })

        return contains
    }

    async clone(): Promise<AsyncCollection<T>> {
        return new AsyncCollection<T>(await this._items.clone())
    }
    
    async diff(items: AsyncCollectionComparable<T>): Promise<Collection<T>> {
        const matches: T[] = []

        await this._chunk(async chunk => {
            for ( const item of chunk.all() ) {
                if ( !(await items.includes(item)) ) {
                    matches.push(item)
                }
            }
        })

        return new Collection<T>(matches)
    }

    async diffUsing(items: AsyncCollectionComparable<T>, compare: DeterminesEquality<T>): Promise<Collection<T>> {
        const matches: T[] = []

        await this._chunk(async chunk => {
            for ( const item of chunk.all() ) {
                if ( !(await items.some(exc => compare(item, exc))) )
                    matches.push(item)
            }
        })

        return new Collection<T>(matches)
    }

    async includes(item: CollectionItem<T>): Promise<boolean> {
        let contains = false

        await this._chunk(items => {
            if ( items.includes(item) ) {
                contains = true
                throw new StopIteration()
            }
        })

        return contains
    }

    async some(operator: (item: T) => boolean): Promise<boolean> {
        let contains = false

        await this._chunk(items => {
            for ( const item of items.all() ) {
                if ( operator(item) ) {
                    contains = true
                    throw new StopIteration()
                }
            }
        })

        return contains
    }
    
    async each<T2>(func: AsyncKeyFunction<T, T2>): Promise<void> {
        let index = 0

        await this._chunk(async items => {
            for ( const item of items.all() ) {
                await func(item, index)
                index += 1
            }
        })
    }

    async map<T2>(func: AsyncKeyFunction<T, T2>): Promise<Collection<T2>> {
        const new_items: CollectionItem<T2>[] = []
        await this.each(async (item, index) => {
            new_items.push(await func(item, index))
        })
        return new Collection<T2>(new_items)
    }

    async every<T2>(func: AsyncKeyFunction<T, T2>): Promise<boolean> {
        let pass = true
        let index = 0

        await this._chunk(async items => {
            for ( const item of items.all() ) {
                if ( !(await func(item, index)) ) {
                    pass = false
                    throw new StopIteration()
                }

                index += 1
            }
        })

        return pass
    }

    async everyWhere<T2>(key: KeyOperator<T, T2>, operator: WhereOperator, operand?: any): Promise<boolean> {
        let pass = true

        await this._chunk(async items => {
            pass = pass && items.everyWhere(key, operator, operand)
            if ( !pass ) {
                throw new StopIteration()
            }
        })

        return pass
    }

    async filter<T2>(func: KeyFunction<T, T2>): Promise<Collection<T>> {
        let new_items: CollectionItem<T>[] = []

        await this._chunk(async items => {
            new_items = new_items.concat(items.filter(func).all())
        })

        return new Collection<T>(new_items)
    }

    when<T2>(bool: boolean, then: AsyncCollectionFunction<T, T2>): AsyncCollection<T> {
        if ( bool ) then(this)
        return this
    }

    unless<T2>(bool: boolean, then: AsyncCollectionFunction<T, T2>): AsyncCollection<T> {
        if ( !bool ) then(this)
        return this
    }

    async where<T2>(key: KeyOperator<T, T2>, operator: WhereOperator, operand?: any): Promise<Collection<T>> {
        let new_items: CollectionItem<T>[] = []
        await this._chunk(async items => {
            new_items = new_items.concat(items.where(key, operator, operand).all())
        })
        return new Collection<T>(new_items)
    }

    async whereNot<T2>(key: KeyOperator<T, T2>, operator: WhereOperator, operand?: any): Promise<Collection<T>> {
        let new_items: CollectionItem<T>[] = []
        await this._chunk(async items => {
            new_items = new_items.concat(items.whereNot(key, operator, operand).all())
        })
        return new Collection<T>(new_items)
    }

    async whereIn<T2>(key: KeyOperator<T, T2>, items: AsyncCollectionComparable<T2>): Promise<Collection<T>> {
        let new_items: CollectionItem<T>[] = []
        await this._chunk_all_associate(key,async chunk => {
            for ( const item of chunk ) {
                if ( await items.includes(item.key) ) {
                    new_items.push(item.item)
                }
            }
        })
        return new Collection<T>(new_items)
    }

    async whereNotIn<T2>(key: KeyOperator<T, T2>, items: AsyncCollectionComparable<T2>): Promise<Collection<T>> {
        let new_items: CollectionItem<T>[] = []
        await this._chunk_all_associate(key,async chunk => {
            for ( const item of chunk ) {
                if ( !(await items.includes(item.key)) ) {
                    new_items.push(item.item)
                }
            }
        })
        return new Collection<T>(new_items)
    }

    async first(): Promise<MaybeCollectionItem<T>> {
        if ( await this._items.count() > 0 ) {
            return this._items.at_index(0)
        }
    }

    async firstWhere<T2>(key: KeyOperator<T, T2>, operator: WhereOperator = '=', operand: any = true): Promise<MaybeCollectionItem<T>> {
        let item = undefined
        await this._chunk_all_associate(key, async items => {
            const matches = applyWhere(items, operator, operand)
            if ( matches.length > 0 ) {
                item = matches[0]
                throw new StopIteration()
            }
        })
        return item
    }

    async firstWhereNot<T2>(key: KeyOperator<T, T2>, operator: WhereOperator = '=', operand: any = true): Promise<MaybeCollectionItem<T>> {
        let item: MaybeCollectionItem<T> = undefined
        await this._chunk(async items => {
            const matches = items.whereNot(key, operator, operand)
            if ( matches.length > 0 ) {
                item = matches.first()
                throw new StopIteration()
            }
        })
        return item
    }

    async count() {
        return this._items.count()
    }

    async length() {
        return this._items.count()
    }

    async get(index: number, fallback?: any) {
        if ( (await this.count()) > index ) return this._items.at_index(index)
        else return fallback
    }

    async at(index: number): Promise<MaybeCollectionItem<T>> {
        return this.get(index)
    }

    async groupBy<T2>(key: KeyOperator<T, T2>): Promise<any> {
        return (await this.collect()).groupBy(key)
    }

    async associate<T2>(key: KeyOperator<T, T2>): Promise<any> {
        return (await this.collect()).associate(key)
    }

    async join(delimiter: string): Promise<string> {
        let running_strings: string[] = []

        await this._chunk(async items => {
            running_strings.push(items.join(delimiter))
        })

        return running_strings.join(delimiter)
    }

    async implode(delimiter: string): Promise<string> {
        return this.join(delimiter)
    }

    // TODO intersect

    async isEmpty(): Promise<boolean> {
        return (await this._items.count()) < 1
    }

    async isNotEmpty(): Promise<boolean> {
        return (await this._items.count()) > 0
    }

    async last(): Promise<MaybeCollectionItem<T>> {
        const length = await this._items.count()
        if ( length > 0 ) return this._items.at_index(length - 1)
    }

    async lastWhere<T2>(key: KeyOperator<T, T2>, operator: WhereOperator, operand?: any): Promise<MaybeCollectionItem<T>> {
        return (await this.where(key, operator, operand)).last()
    }

    async lastWhereNot<T2>(key: KeyOperator<T, T2>, operator: WhereOperator, operand?: any): Promise<MaybeCollectionItem<T>> {
        return (await this.whereNot(key, operator, operand)).last()
    }

    async pluck<T2>(key: KeyOperator<T, T2>): Promise<Collection<T2>> {
        let new_items: CollectionItem<T2>[] = []

        await this._chunk_all(key, async items => {
            new_items = new_items.concat(items.all())
        })

        return new Collection<T2>(new_items)
    }

    async max<T2>(key: KeyOperator<T, T2>): Promise<number> {
        let running_max: number

        await this._chunk_all_numbers(key, async items => {
            const local_max = Math.max(...items)
            if ( typeof running_max === 'undefined' ) running_max = local_max
            else running_max = Math.max(running_max, local_max)
        })

        // @ts-ignore
        return running_max
    }

    async whereMax<T2>(key: KeyOperator<T, T2>): Promise<Collection<T>> {
        return this.where(key, '=', await this.max(key))
    }

    async min<T2>(key: KeyOperator<T, T2>): Promise<number> {
        let running_min: number

        await this._chunk_all_numbers(key, async items => {
            const local_min = Math.min(...items)
            if ( typeof running_min === 'undefined' ) running_min = local_min
            else running_min = Math.min(running_min, local_min)
        })

        // @ts-ignore
        return running_min
    }

    async whereMin<T2>(key: KeyOperator<T, T2>): Promise<Collection<T>> {
        return this.where(key, '=', await this.min(key))
    }

    async merge<T2>(merge_with: AsyncCollectionComparable<T2>): Promise<Collection<T|T2>> {
        let items: T2[]
        if ( merge_with instanceof Collection ) items = await merge_with.all()
        else if ( merge_with instanceof AsyncCollection ) items = await merge_with.all()
        else if ( Array.isArray(merge_with) ) items = merge_with

        // @ts-ignore
        return new Collection<T|T2>([...items, ...await this.all()])
    }

    async nth(n: number): Promise<Collection<T>> {
        const matches: CollectionItem<T>[] = []
        let current = 1

        await this._chunk(async chunk => {
            for ( const item of chunk.all() ) {
                if ( current === 1 ) matches.push(item)
                current += 1
                if ( current > n ) current = 1
            }
        })

        return new Collection<T>(matches)
    }

    async forPage(page: number, per_page: number): Promise<Collection<T>> {
        const start = page * per_page - per_page
        const end = page * per_page - 1
        return this._items.from_range(start, end)
    }

    pipe<T2>(func: AsyncCollectionFunction<T, T2>): any {
        return func(this)
    }

    /*async pop(): Promise<MaybeCollectionItem<T>> {
        const next_item = await this._items.next()
        if ( !next_item.done ) {
            return next_item.value
        }
    }*/ // TODO Fix this

    async random(n: number): Promise<Collection<T>> {
        const random_items: CollectionItem<T>[] = []
        const fetched_indices: number[] = []

        const max_n = await this._items.count()
        if ( n > max_n ) n = max_n

        while ( random_items.length < n ) {
            const index = Math.floor(Math.random() * max_n)

            if ( !fetched_indices.includes(index) ) {
                fetched_indices.push(index)
                random_items.push(await this._items.at_index(index))
            }
        }

        return new Collection<T>(random_items)
    }

    async reduce<T2>(reducer: KeyReducerFunction<T, T2>, initial_value?: T2): Promise<T2 | undefined> {
        let current_value = initial_value
        let index = 0

        await this._chunk(async items => {
            for ( const item of items.all() ) {
                current_value = reducer(current_value, item, index)
                index += 1
            }
        })

        return current_value
    }

    async reject<T2>(truth_test: AsyncKeyFunction<T, T2>): Promise<Collection<T>> {
        let rejected: CollectionItem<T>[] = []

        await this._chunk(async items => {
            rejected = rejected.concat(items.all().filter((item, index) => {
                return !truth_test(item, index)
            }))
        })

        return new Collection<T>(rejected)
    }

    async reverse(): Promise<Collection<T>> {
        return (await this.collect()).reverse()
    }

    async search(item: CollectionItem<T>): Promise<MaybeCollectionIndex> {
        let found_index
        let index = 0

        await this._chunk(async items => {
            items.some(possible_item => {
                if ( possible_item === item ) {
                    found_index = index
                    throw new StopIteration()
                }

                index += 1
                return false
            })
        })

        return found_index
    }

    async shift(): Promise<MaybeCollectionItem<T>> {
        const next_item = await this._items.next()
        if ( !next_item.done ) {
            return next_item.value
        }
    }

    async shuffle(): Promise<Collection<T>> {
        return (await this.collect()).shuffle()
    }

    async slice(start: number, end: number): Promise<Collection<T>> {
        return this._items.from_range(start, end - 1)
    }

    async sort(compare_func?: ComparisonFunction<T>): Promise<Collection<T>> {
        return (await this.collect()).sort(compare_func)
    }

    async sortBy<T2>(key?: KeyOperator<T, T2>): Promise<Collection<T>> {
        return (await this.collect()).sortBy(key)
    }

    async sortDesc(compare_func?: ComparisonFunction<T>): Promise<Collection<T>> {
        return (await this.collect()).sortDesc(compare_func)
    }

    async sortByDesc<T2>(key?: KeyOperator<T, T2>): Promise<Collection<T>> {
        return (await this.collect()).sortByDesc(key)
    }

    async splice(start: CollectionIndex, deleteCount?: number): Promise<Collection<T>> {
        return (await this.collect()).splice(start, deleteCount)
    }

    async sum<T2>(key?: KeyOperator<T, T2>): Promise<number> {
        let running_sum: number = 0

        const chunk_handler = (items: number[]) => {
            for ( const item of items ) {
                running_sum += item
            }
        }

        if ( key ) await this._chunk_all_numbers(key, chunk_handler)
        else await this._chunk(async chunk => {
            chunk_handler(chunk.map(x => Number(x)).all())
        })

        return running_sum
    }

    async take(limit: number): Promise<Collection<T>> {
        if ( limit === 0 ) return new Collection<T>()
        else if ( limit > 0 ) {
            return this.slice(0, limit)
        } else {
            const cnt = await this._items.count()
            return this._items.from_range(cnt - (-1 * limit), cnt - 1)
        }
    }

    async tap<T2>(func: AsyncCollectionFunction<T, T2>): Promise<AsyncCollection<T>> {
        await func(this)
        return this
    }

    async unique<T2>(key?: KeyOperator<T, T2>): Promise<Collection<T|T2>> {
        const has: CollectionItem<T|T2>[] = []

        if ( !key ) {
            await this._chunk(async items => {
                for ( const item of items.all() ) {
                    if ( !has.includes(item) ) has.push(item)
                }
            })
        } else {
            await this._chunk_all(key, async items => {
                for ( const item of items.all() ) {
                    if ( !has.includes(item) ) has.push(item)
                }
            })
        }

        return new Collection<T|T2>(has)
    }

    async toArray(): Promise<any[]> {
        const returns: any = []
        for ( const item of (await this.all()) ) {
            if ( item instanceof Collection ) returns.push(item.toArray())
            else if ( item instanceof AsyncCollection ) returns.push(await item.toArray())
            else returns.push(item)
        }
        return returns
    }

    async toJSON(replacer = undefined, space = 4): Promise<string> {
        return JSON.stringify(this.toArray(), replacer, space)
    }

    [Symbol.asyncIterator]() {
        return this._items.clone()
    }

    iterator() {
        return this._items.clone()
    }
}