import { $NAME, $CONSTRUCTOR } from '../../MetaContext';
import { $ASSIGN, Assign, deepAssign } from '../../operations/base/$assign';
import { $CLONE, Clone, deepClone } from '../../operations/base/$clone';
import { $COMPARE, Compare, deepCompare } from '../../operations/base/$compare';
import { $CONSTRUCT, Construct, genericConstruct } from '../../operations/base/$construct';
import { $DUMP, Dump, deepDump } from '../../operations/base/$dump';
import { $EQUAL, Equal, deepEqual } from '../../operations/base/$equal';
import { $HASH, Hash, deepHash } from '../../operations/base/$hash';
import { $RESTORE, $CREATE, Restore, Create, deepRestore, genericCreate } from '../../operations/base/$restore';
import { $SERIALIZE, primitiveSerialize } from '../../operations/base/$serialize';
import { $STRINGIFY, Stringify, deepStringify, stringifyArrayWrapper } from '../../operations/base/$stringify';

export function assign<T>(lhs: T[], rhs: T[], assignfn: Assign<T>, clonefn: Clone<T>, context?: any) {
    const minLength = Math.min(lhs.length, rhs.length);
    lhs.length = rhs.length;
    let i = 0;
    for (; i < minLength; i++)
        lhs[i] = assignfn.call(context, lhs[i], rhs[i]);
    for (; i < lhs.length; i++)
        lhs[i] = clonefn.call(context, rhs[i]);
    return lhs;
}

export function clone<T>(arr: T[], clonefn: Clone<T>, constructfn: Construct<T[]>, context?: any) {
    const length = arr.length;
    const ret = constructfn(length);
    for (let i = 0; i < length; i++)
        ret[i] = clonefn.call(context, arr[i]);
    return ret;
}

export function compare<T>(lhs: T[], rhs: T[], comparefn: Compare<T>, context?: any) {
    const lhsLength = lhs.length;
    const rhsLength = rhs.length;
    const minLength = Math.min(lhsLength, rhsLength);
    for (let i = 0; i < minLength; i++) {
        const result = comparefn.call(context, lhs[i], rhs[i]);
        if (result !== 0)
            return result;
    }
    return lhsLength - rhsLength;
}

export function dump<T>(arr: T[], dumpfn: Dump<T>, context?: any) {
    const length = arr.length;
    const ret = new Array(length);
    for (let i = 0; i < length; i++)
        ret[i] = dumpfn.call(context, arr[i]);
    return ret;
}

export function equal<T>(lhs: T[], rhs: T[], equalfn: Equal<T>, context?: any) {
    const length = lhs.length;
    if (length !== rhs.length)
        return false;
    for (let i = 0; i < length; i++)
        if (!equalfn.call(context, lhs[i], rhs[i]))
            return false;
    return true;
}

export function hash<T>(arr: T[], hashfn: Hash<T>, seed = 0, context?: any) {
    for (let i = 0; i < arr.length; i++)
        seed = hashfn.call(context, arr[i], seed);
    return seed;
}

export function restore<T>(arr: T[], state: any, restorefn: Restore<T>, createfn: Create<T>, context?: any) {
    const minLength = Math.min(arr.length, state.length);
    arr.length = state.length;
    let i = 0;
    for (; i < minLength; i++)
        arr[i] = restorefn.call(context, arr[i], state[i]);
    for (; i < arr.length; i++)
        arr[i] = createfn.call(context, state[i]);
    return arr;
}

export function stringify<T>(arr: T[], stringifyfn: Stringify<T>, context?: any) {
    return arr.map((value: any) => stringifyfn.call(context, value)).join(', ');
}

export const $assign = deepAssign<any[], any>(assign);

export const $clone = deepClone<any[], any>(clone);

export const $compare = deepCompare<any[], any>(compare);

export const $construct = genericConstruct;

export const $create = genericCreate;

export const $dump = deepDump<any[], any>(dump);

export const $equal = deepEqual<any[], any>(equal);

export const $hash = deepHash<any[], any>(hash);

export const $restore = deepRestore<any[], any>(restore);

export const $serialize = primitiveSerialize;

export const $stringify = deepStringify<any[], any>(stringify, stringifyArrayWrapper);

export const $constructor = Array;

export const $name = 'Array';

export const $tag = {
    [$CONSTRUCTOR]: $constructor,
    [$NAME]: $name
};

export default {
    [$CONSTRUCTOR]: $constructor,
    [$NAME]: $name,
    [$ASSIGN]: $assign,
    [$CLONE]: $clone,
    [$COMPARE]: $compare,
    [$CONSTRUCT]: $construct,
    [$CREATE]: $create,
    [$DUMP]: $dump,
    [$EQUAL]: $equal,
    [$HASH]: $hash,
    [$RESTORE]: $restore,
    [$SERIALIZE]: $serialize,
    [$STRINGIFY]: $stringify
};