import { CostFn } from "../methods/cost"
import { Mutation } from "../methods/mutation"
import { RatePolicy } from "../methods/rate"
import { Connection } from "./connection"
import { Node, NodeVal } from "./node"
import * as neataptic from "neataptic"

export type TrainingVal = {input: number[], output: number[]}

export type TrainingResult = {
    error: number,
    iterations: number,
    time: number,
}

export type ScheduleFn = (data: TrainingResult) => void

export type ScheduleConfig = {function: ScheduleFn, iterations: number}

export type TrainingOptions = {
    log?: number,
    error?: number,
    cost?: CostFn,
    rate?: number,
    dropout?: number,
    shuffle?: boolean,
    iterations?: number,
    schedule?: ScheduleConfig,
    clear?: boolean,
    momentum?: number,
    ratePolicy?: RatePolicy,
    batchSize?: number,
}

export type EvolveOptions = {
    cost?: CostFn,
    amount?: number,
    growth?: number,
    iterations?: number,
    error?: number,
    log?: number,
    schedule?: ScheduleConfig,
    clear?: boolean,
    threads?: number,
}

export interface Network {
    input: number
    output: number
    nodes: Node[]
    connections: Connection[]
    gates: Connection[],
    selfconns: Connection[]

    activate: (input: number[]) => number[]
    noTraceActivate: (input: number[]) => number[]
    propagate: (rate: number, momentum: number, update: boolean, target: number[]) => void
    connect: (n1: Node, n2: Node) => Connection[]
    remove: (n: Node) => void
    disconnect: (n1: Node, n2: Node) => void
    gate: (n: Node, c: Connection) => void
    ungate: (c: Connection) => void
    mutate: (m: Mutation<any>) => void
    serialize: () => [Float64Array, Float64Array, Float64Array]
    toJSON: () => object
    standalone: () => string
    set: (v: NodeVal) => void
    clear: () => void
    train: (vals: TrainingVal[], opts: TrainingOptions) => TrainingResult
    evolve: (vals: TrainingVal[], opts: EvolveOptions) => TrainingResult
}

export const merge: (n1: Network, n2: Network) => Network = neataptic.Network.merge

export const crossOver: (n1: Network, n2: Network) => Network = neataptic.Network.crossOver

export const fromJSON: (o: object) => Network = neataptic.Network.fromJSON

export function create(i: number, o: number): Network {
    return new neataptic.Network(i, o)
}

export const classConstructor: (i: number, o: number) => void = neataptic.Network