export enum SimilarityFunction {
    Euclidean, 
    Minkowski, 
    Cosine, 
    AngularCosine, 
    Jaccard
}

/**
 *  defines gaps parameters required for alignment
 *   
 *  @member gapOpen: number, penalty for opening a gap 
 *  @member gapExt: number or None (default), penalty for extending an existing gap.
 *                  if gap_ext is None, the scoring assumes a linear gap penalty,
 *                  else the scoring assumes affine gap penalty              
 */
export type GapsParams = {
    gapOpen: number,
    gapExt: number | undefined
}

export enum GapType {
    LINEAR, 
    AFFINE
}

export type Triple = [number, number, number]
export type TripleTable = Triple[][]
export type DynamicTable = number[][]

export type AffineGapAlignment = {
    V: DynamicTable,
    Vp: TripleTable,

    E: DynamicTable,
    Ep: TripleTable,
    
    F: DynamicTable, 
    Fp: TripleTable,
    
    end_i: number,
    end_j: number
}

export type LinearGapAlignment = {
    V: DynamicTable,
    Vp: TripleTable,
    end_i: number, 
    end_j: number
}

export function isAffineGapAlignment(alignment: LinearGapAlignment | AffineGapAlignment): alignment is AffineGapAlignment {
   return (<AffineGapAlignment>alignment).E !== undefined;
}

export type Graph<T> = Map<T, T[]>

export enum TableName {
    None, V, E, F
}

export type DirectedPosition = [Position, TableName]

export type AlignmentPair<LabelType> = [LabelType, LabelType]
export type Path<LabelType> = Array<AlignmentPair<LabelType>>
export type PathMap<LabelType> = Map<Position | DirectedPosition, Path<LabelType>>

export enum AlignType {
    Global, 
    Local, 
    SemiGlobal,
    EndGapFree
}

export type Position = [number, number]

export type AlignmentResult<LabelType> = {
    score: number, 
    paths: Path<LabelType>[]
}