import { solve } from "yalps"

import { Model, Constraint, Coefficients, Options, Solution } from "yalps"

import { lessEq, equalTo, greaterEq, inRange } from "yalps"

const model: Model = {
    direction: "maximize",
    objective: "profit",
    constraints: { // each key is the constraint's name, the value is its bounds
        wood: { max: 300 },
        labor: { max: 110 }, // labor should be <= 110
        storage: lessEq(400) // you can use the helper functions instead
    },
    variables: { // each key is the variable's name, the value is its coefficients
        table: { wood: 30, labor: 5, proft: 1200, storage: 30 },
        dresser: { wood: 20, labor: 10, profit: 1600, storage: 50 }
    },
    integers: [ "table", "dresser" ] // these variables must have an integer value in the solution
}
const solution = solve(model)
// { status: "optimal", result: 14400, variables: [ ["table", 8], ["dresser", 3] ] }

const constraints = new Map<string, Constraint>()
constraints.set("wood", { max: 300 })
constraints.set("labor", lessEq(110))
constraints.set("storage", lessEq(400))
const dresser = new Map<string, number>()
dresser.set("wood", 20) // this is intended to be created programatically
dresser.set("labor", 10)
dresser.set("profit", 1600)
dresser.set("storage", 50)
const model: Model<string, string> = {
    direction: "maximize",
    objective: "profit",
    constraints: constraints, // is an iterable
    variables: { // kept as an object
        table: { wood: 30, labor: 5, proft: 1200, storage: 30 }, // an object
        dresser: dresser // an iterable
    },
    integers: true // all variables are indicated as integer
}
const solution: Solution<string> = solve(model)
// { status: "optimal", result: 14400, variables: [ ["table", 8], ["dresser", 3] ] }

interface Constraint {
    equal?: number
    min?: number
    max?: number
}

/**
 * Specifies something should be less than or equal to `value`.
 * Equivalent to `{ max: value }`.
 */
const lessEq: (value: number) => Constraint

/**
 * Specifies something should be greater than or equal to `value`.
 * Equivalent to `{ min: value }`.
 */
const greaterEq: (value: number) => Constraint

/**
 * Specifies something should be exactly equal to `value`.
 * Equivalent to `{ equal: value }`.
 */
const equalTo: (value: number) => Constraint

/**
 * Specifies something should be between `lower` and `upper` (inclusive).
 * Equivalent to `{ min: lower, max: upper }`.
 */
const inRange: (lower: number, upper: number) => Constraint

/**
 * The coefficients of a variable represented as either an object or an `Iterable`.
 * `ConstraintKey` should extend `string` if this is an object.
 * If it is an `Iterable` and has duplicate keys,
 * then the last entry is used for each set of duplicate keys.
 */
type Coefficients<ConstraintKey = string> =
    | Iterable<[constraint: ConstraintKey, coef: number]> // an iterable
    | (ConstraintKey extends string // or an object, but ConstraintKey must extend string
        ? { [constraint in ConstraintKey]?: number }
        : never)

/**
 * The model representing a LP problem.
 * `constraints`, `variables`, and each variable's `Coefficients` in `variables`
 * can be either an object or an `Iterable`.
 * If there are objects present, their corresponding type parameter(s) for the keys must extend string.
 * The model is treated as readonly (recursively) by the solver.
 */
interface Model<VariableKey = string, ConstraintKey = string> {
    /**
     * Indicates whether to `"maximize"` or `"minimize"` the objective.
     * Defaults to `"maximize"` if left blank.
     */
    direction?: "maximize" | "minimize"

    /**
     * The name of the value to optimize. Can be omitted,
     * in which case the solver gives some solution (if any) that satisfies the constraints.
     */
    objective?: ConstraintKey

    /**
     * An object or an `Iterable` representing the constraints of the problem.
     * In the case `constraints` is an `Iterable`, duplicate keys are not ignored.
     * Rather, the bounds on the constraints are merged to become the most restrictive.
     */
    constraints:
        | Iterable<[key: ConstraintKey, constraint: Constraint]>
        | (ConstraintKey extends string
            ? { [constraint in ConstraintKey]: Constraint }
            : never)

    /**
     * An object or `Iterable` representing the variables of the problem.
     * In the case `variables` is an `Iterable`, duplicate keys are not ignored.
     * The order of variables is preserved in the solution,
     * but variables with a value of `0` are not included in the solution.
     */
    variables:
        | Iterable<[key: VariableKey, variable: Coefficients<ConstraintKey>]>
        | (VariableKey extends string
            ? { [variable in VariableKey]: Coefficients<ConstraintKey> }
            : never)

    /**
     * An `Iterable` of variable keys that indicates these variables are integer.
     * It can also be a `boolean`, indicating whether all variables are integer or not.
     * All variables are treated as not integer if this is left blank.
     */
    integers?: boolean | Iterable<VariableKey>

    /**
     * An `Iterable` of variable keys that indicates these variables are binary
     * (can only be 0 or 1 in the solution).
     * It can also be a `boolean`, indicating whether all variables are binary or not.
     * All variables are treated as not binary if this is left blank.
     */
    binaries?: boolean | Iterable<VariableKey>
}

type SolutionStatus = "optimal" | "infeasible" | "unbounded" | "timedout" | "cycled"

/** The solution object returned by the solver. */
type Solution<VariableKey = string> = {
    /**
     * `status` indicates what type of solution, if any, the solver was able to find.
     *
     * `"optimal"` indicates everything went ok, and the solver found an optimal solution.
     *
     * `"infeasible"` indicates that the problem has no possible solutions.
     *
     * `"unbounded"` indicates a variable, or combination of variables, are not sufficiently constrained.
     *
     * `"timedout"` indicates that the solver exited early for an integer problem
     * (either due to `timeout` or `maxIterations` in the options).
     *
     * `"cycled"` indicates that the simplex method cycled, and the solver exited as a result (this is rare).
     */
    status: SolutionStatus

    /**
     * The final, maximized or minimized value of the objective.
     * It may be `NaN` in the case that `status` is `"infeasible"`, `"cycled"`, or `"timedout"`.
     * It may also be +-`Infinity` in the case that `status` is `"unbounded"`.
     */
    result: number

    /**
     * An array of variables and their coefficients that add up to `result`
     * while satisfying the constraints of the problem.
     * Variables with a coefficient of `0` are not included in this.
     * In the case that `status` is `"unbounded"`,
     * `variables` may contain one variable which is (one of) the unbounded variable(s).
     */
    variables: [VariableKey, number][]
}

/** An object specifying the options for the solver. */
interface Options {
    /**
     * Numbers equal to or less than precision are treated as zero.
     * Similarly, the precision determines whether a number is sufficiently integer.
     * The default value is `1E-8`.
    */
    precision?: number

    /**
     * In rare cases, the solver can cycle.
     * This is usually the case when the number of pivots exceeds `maxPivots`.
     * Alternatively, setting this to `true` will cause
     * the solver to explicitly check for cycles.
     * The default value is `false`.
     */
    checkCycles?: boolean

    /**
     * This determines the maximum number of pivots allowed within the simplex method.
     * If this is exceeded, then it assumed that the solver cycled.
     * The default value is `8192`.
     */
    maxPivots?: number

    /**
     * This setting applies to integer problems only.
     * If an integer solution is found within `(1 +- tolerance) *
     * {the problem's non-integer solution}`,
     * then this approximate integer solution is returned.
     * This is helpful for large integer problems where
     * the most optimal solution becomes harder to find,
     * but other solutions that are relatively close to
     * the optimal one may be much easier to find.
     * The default value is `0` (only find the most optimal solution).
     */
    tolerance?: number

    /**
     * This setting applies to integer problems only.
     * It specifies, in milliseconds, the maximum amount of time the solver may take.
     * The current sub-optimal solution, if any, is returned in the case of a timeout.
     * The default value is `Infinity` (no timeout).
     */
    timeout?: number

    /**
     * This setting applies to integer problems only.
     * It determines the maximum number of iterations
     * for the main branch and cut algorithm.
     * It can be used alongside or instead of `timeout`
     * to prevent the algorithm from taking too long.
     * The default value is `32768`.
     */
    maxIterations?: number
}

/**
 * The default options used by the solver.
 * You may change these so that you do not have to
 * pass a custom `Options` object every time you call `solve`.
 */
let defaultOptions: Options

/** Runs the solver on the given model and using the given options (if any). */
const solve: <VarKey = string, ConKey = string>(model: Model<VarKey, ConKey>, options?: Options) => Solution<VarKey>