import { map } from 'ramda'
import * as assert from 'assert'
//console.log(map(x=> x ** 2, [1, 2, 3, 4, 5]))

interface BinTree {
    root: number;
    left?: BinTree;
    right?: BinTree;
};
// 2.1.1
type treeFunc = (t:BinTree) => number[];
const TreePreArray : treeFunc =
t=> {
    let result:number[]= [];
    result.push(t.root);
    if(t.left!==undefined)
        result = result.concat(TreePreArray(t.left));
    if(t.right!==undefined)
        result = result.concat(TreePreArray(t.right));
    return result;
}
// 2.1.2
const TreeInArray : treeFunc =
t=> {
    let result:number[]= [];
    if(t.left!==undefined)
        result = result.concat(TreePreArray(t.left));
    result.push(t.root);
    if(t.right!==undefined)
        result = result.concat(TreePreArray(t.right));
    return result;
}
// 2.1.3
const TreePostArray : treeFunc =
t=> {
    let result:number[]= [];
    if(t.left!==undefined)
        result = result.concat(TreePreArray(t.left));
    if(t.right!==undefined)
        result = result.concat(TreePreArray(t.right));
    result.push(t.root);
    return result;
}


let t1:BinTree = {root:1,left:{root:2,left:undefined,right:undefined},right:{root:3,left:undefined,right:undefined}}
let t2:BinTree = {root:1,left:{root:2,left:undefined,right:undefined},right:undefined}
let t3:BinTree = {root:1,left:undefined,right:{root:3,left:undefined,right:undefined}}

// 2.1.1 tests
assert.deepEqual(TreePreArray(t1), [1, 2, 3], "Preorder - Test1 - BinTrees Not equal");
assert.deepEqual(TreePreArray(t2), [1, 2], "Preorder - Test2 - BinTrees Not equal");
assert.deepEqual(TreePreArray(t3), [1, 3], "Preorder - Test3 - BinTrees Not equal");
// 2.1.2 tests
assert.deepEqual(TreeInArray(t1), [2, 1, 3], "Inorder - Test1 - BinTrees Not equal");
assert.deepEqual(TreeInArray(t2), [2, 1], "Inorder - Test2 - BinTrees Not equal");
assert.deepEqual(TreeInArray(t3), [1, 3], "Inorder - Test3 - BinTrees Not equal");
// 2.1.3 tests
assert.deepEqual(TreePostArray(t1), [2, 3, 1], "Postorder - Test1 - BinTrees Not equal");
assert.deepEqual(TreePostArray(t2), [2, 1], "Postorder - Test2 - BinTrees Not equal");
assert.deepEqual(TreePostArray(t3), [3, 1], "Postorder - Test3 - BinTrees Not equal");


interface GBinTree<T> {
    root: T;
    left?: GBinTree<T>;
    right?: GBinTree<T>;
};
// 2.1.4

type GtreeFunc = <T>(t:GBinTree<T>) => T[];
const GTreePreArray : GtreeFunc =
t => {
    if(t.root === undefined)
        return [];
    type arrayType = typeof t.root;
    let result:arrayType[] = [];
    result.push(t.root);
    if(t.left!==undefined)
        result = result.concat(GTreePreArray(t.left));
    if(t.right!==undefined)
        result = result.concat(GTreePreArray(t.right));
    return result;
}

// 2.1.5
const GTreeInArray : GtreeFunc =
t=> {
    if(t.root === undefined)
        return [];
    type arrayType = typeof t.root;
    let result:arrayType[] = [];
    if(t.left!==undefined)
        result = result.concat(GTreePreArray(t.left));
    result.push(t.root);
    if(t.right!==undefined)
        result = result.concat(GTreePreArray(t.right));
    return result;
}
// 2.1.6
const GTreePostArray : GtreeFunc =
t=> {
    if(t.root === undefined)
        return [];
    type arrayType = typeof t.root;
    let result:arrayType[] = [];
    if(t.left!==undefined)
        result = result.concat(GTreePreArray(t.left));
    if(t.right!==undefined)
        result = result.concat(GTreePreArray(t.right));
    result.push(t.root);
    return result;
}

let s1:GBinTree<String> = {root:"ab",left:{root:"cd",left:undefined,right:undefined},right:{root:"ef",left:undefined,right:undefined}}
let s2:GBinTree<String> = {root:"ab",left:{root:"cd",left:undefined,right:undefined},right:undefined}
let s3:GBinTree<String> = {root:"ab",left:undefined,right:{root:"ef",left:undefined,right:undefined}}
let s4:GBinTree<String> = {root:undefined,left:undefined,right:undefined}
//assert.deepEqual(GTreePreArray(s4), [], "empty check");
//console.log(GTreePreArray(s4));
// 2.1.4 tests
assert.deepEqual(GTreePreArray(s1), ["ab", "cd", "ef"], "Preorder - Test1 - GBinTrees Not equal");
assert.deepEqual(GTreePreArray(s2), ["ab", "cd"], "Preorder - Test2 - GBinTrees Not equal");
assert.deepEqual(GTreePreArray(s3), ["ab", "ef"], "Preorder - Test3 - GBinTrees Not equal");
// 2.1.5 tests
assert.deepEqual(GTreeInArray(s1), ["cd", "ab", "ef"], "Inorder - Test1 - GBinTrees Not equal");
assert.deepEqual(GTreeInArray(s2), ["cd", "ab"], "Inorder - Test2 - GBinTrees Not equal");
assert.deepEqual(GTreeInArray(s3), ["ab", "ef"], "Inorder - Test3 - GBinTrees Not equal");
// 2.1.6 tests
assert.deepEqual(GTreePostArray(s1), ["cd", "ef", "ab"], "Postorder - Test1 - GBinTrees Not equal");
assert.deepEqual(GTreePostArray(s2), ["cd", "ab"], "Postorder - Test2 - GBinTrees Not equal");
assert.deepEqual(GTreePostArray(s3), ["ef", "ab"], "Postorder - Test3 - GBinTrees Not equal");

type T4=<T>(f:((x:T)=>any[]),a:T[])=>any[]
const Flatmap:T4=(f,a)=>{
    let newarr=a.map(f)
    newarr=newarr.reduce((acc, cur)=>acc.concat(cur), [])
    return newarr
}



console.log(Flatmap((x)=>x[0], [[[1,2], [3,4]], [[5,6], [7,8]]]))