import { number } from "yargs"
import { Position, TripleTable } from "./types"

export function initializeTable<T>(rows: number, columns: number, value: T): T[][] {
    return new Array<T>(rows).fill(value).map(() => new Array<T>(columns).fill(value))
}

// like indexOf, but returns an array of all values.
export function indicesOf<T>(arr: Array<T>, searchValue: T): Array<number> {
    return arr.reduce((acc, val, index) => {
        if (val === searchValue)
            acc.push(index)
        return acc
    }, new Array<number>())
}

export function lastColumnOf<T>(arr: T[][]): T[] {
    return arr.map((row: T[]) => row[row.length-1])
}

export function lastRowOf<T>(arr: T[][]): T[] {
    return arr[arr.length-1]
}

export function indicesInTable<T>(arr: T[][], search: T): Position[] {
    return arr.reduce((acc: Position[], currentRow: T[], rowIndex: number) => {
        let colIndices = indicesOf(currentRow, search)
        for (const colIndex of colIndices) acc.push([rowIndex, colIndex])
        return acc
    }, [] as Position[])
}

/**
  * 
  * @param lengthSeq1 Length of the first sequence
  * @param lengthSeq2 Length of the second sequence
  * @returns a table of  triples where the first column is pointing up (i.e. [0, 0, 1]) and the first 
  * row is pointing left (i.e. [1, 0, 0]).
  */
export function initializePointerTable(lengthSeq1: number, lengthSeq2: number): TripleTable {
    let P: TripleTable = initializeTable(lengthSeq1+1, lengthSeq2+1, [0, 0, 0])
    for (let i=1; i<lengthSeq1+1; i++) {
        P[i][0] = [0 ,0, 1]
    }
    for (let j=1; j<lengthSeq2+1; j++) {
        P[0][j] = [1, 0, 0]
    }
    return P
}

export function fillByIndex(length: number, callback: (i: number) => number): number[] {
    return new Array<number>(length).fill(0).map((v, i) => callback(i))
}