# UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
# Released under the modified BSD license. See COPYING.md for more details.

"""
    optimize!(
        instance::UnitCommitmentInstance, 
        method::TimeDecomposition;
        optimizer,
        after_build = nothing,
        after_optimize = nothing,
    )::OrderedDict

Solve the given unit commitment instance with time decomposition. 
The model solves each sub-problem of a given time length specified by method.time_window,
and proceeds to the next sub-problem by incrementing the time length of `method.time_increment`.

Arguments
---------

- `instance`:
    the UnitCommitment instance.

- `method`:
    the `TimeDecomposition` method.

- `optimizer`:
    the optimizer for solving the problem.

- `after_build`:
    a user-defined function that allows modifying the model after building,
    must have 2 arguments `model` and `instance` in order.

- `after_optimize`:
    a user-defined function that allows handling additional steps after optimizing,
    must have 3 arguments `solution`, `model` and `instance` in order.


Examples
--------

```julia
using UnitCommitment, JuMP, Cbc, HiGHS

import UnitCommitment: 
    TimeDecomposition,
    ConventionalLMP,
    XavQiuWanThi2019,
    Formulation

# specifying the after_build and after_optimize functions
function after_build(model, instance)
    @constraint(
        model,
        model[:is_on]["g3", 1] + model[:is_on]["g4", 1] <= 1,
    )
end

lmps = []
function after_optimize(solution, model, instance)
    lmp = UnitCommitment.compute_lmp(
        model,
        ConventionalLMP(),
        optimizer = HiGHS.Optimizer,
    )
    return push!(lmps, lmp)
end

# assume the instance is given as a 120h problem
instance = UnitCommitment.read("instance.json")

solution = UnitCommitment.optimize!(
    instance,
    TimeDecomposition(
        time_window = 36,  # solve 36h problems
        time_increment = 24,  # advance by 24h each time
        inner_method = XavQiuWanThi2019.Method(),
        formulation = Formulation(),
    ),
    optimizer = Cbc.Optimizer,
    after_build = after_build,
    after_optimize = after_optimize,
)
"""

function optimize!(
    instance::UnitCommitmentInstance,
    method::TimeDecomposition;
    optimizer,
    after_build = nothing,
    after_optimize = nothing,
)::OrderedDict
    # get instance total length
    T = instance.time
    solution = OrderedDict()
    if length(instance.scenarios) > 1
        for sc in instance.scenarios
            solution[sc.name] = OrderedDict()
        end
    end
    # for each iteration, time increment by method.time_increment
    for t_start in 1:method.time_increment:T
        t_end = t_start + method.time_window - 1
        # if t_end exceed total T
        t_end = t_end > T ? T : t_end
        # slice the model 
        @info "Solving the sub-problem of time $t_start to $t_end..."
        sub_instance = UnitCommitment.slice(instance, t_start:t_end)
        # build and optimize the model 
        sub_model = UnitCommitment.build_model(
            instance = sub_instance,
            optimizer = optimizer,
            formulation = method.formulation,
        )
        if after_build !== nothing
            @info "Calling after build..."
            after_build(sub_model, sub_instance)
        end
        UnitCommitment.optimize!(sub_model, method.inner_method)
        # get the result of each time period
        sub_solution = UnitCommitment.solution(sub_model)
        if after_optimize !== nothing
            @info "Calling after optimize..."
            after_optimize(sub_solution, sub_model, sub_instance)
        end
        # merge solution 
        if length(instance.scenarios) == 1
            _update_solution!(solution, sub_solution, method.time_increment)
        else
            for sc in instance.scenarios
                _update_solution!(
                    solution[sc.name],
                    sub_solution[sc.name],
                    method.time_increment,
                )
            end
        end
        # set the initial status for the next sub-problem
        _set_initial_status!(instance, solution, method.time_increment)
    end
    return solution
end

"""
    _set_initial_status!(
        instance::UnitCommitmentInstance,
        solution::OrderedDict,
        time_increment::Int,
    )

Set the thermal units' initial power levels and statuses based on the last bunch of time slots 
specified by time_increment in the solution dictionary.
"""
function _set_initial_status!(
    instance::UnitCommitmentInstance,
    solution::OrderedDict,
    time_increment::Int,
)
    for sc in instance.scenarios
        for thermal_unit in sc.thermal_units
            if length(instance.scenarios) == 1
                prod = solution["Thermal production (MW)"][thermal_unit.name]
                is_on = solution["Is on"][thermal_unit.name]
            else
                prod =
                    solution[sc.name]["Thermal production (MW)"][thermal_unit.name]
                is_on = solution[sc.name]["Is on"][thermal_unit.name]
            end
            thermal_unit.initial_power = prod[end]
            thermal_unit.initial_status = _determine_initial_status(
                thermal_unit.initial_status,
                is_on[end-time_increment+1:end],
            )
        end
    end
end

"""
    _determine_initial_status(
        prev_initial_status::Union{Float64,Int},
        status_sequence::Vector{Float64},
    )::Union{Float64,Int}

Determines a thermal unit's initial status based on its previous initial status, and
the on/off statuses in the last operation.
"""
function _determine_initial_status(
    prev_initial_status::Union{Float64,Int},
    status_sequence::Vector{Float64},
)::Union{Float64,Int}
    # initialize the two flags
    on_status = prev_initial_status
    off_status = prev_initial_status
    # read through the status sequence
    # at each time if the unit is on, reset off_status, increment on_status
    # if the on_status < 0, set it to 1.0
    # at each time if the unit is off, reset on_status, decrement off_status
    # if the off_status > 0, set it to -1.0
    for status in status_sequence
        if status == 1.0
            on_status = on_status < 0.0 ? 1.0 : on_status + 1.0
            off_status = 0.0
        else
            on_status = 0.0
            off_status = off_status > 0.0 ? -1.0 : off_status - 1.0
        end
    end
    # only one of them has non-zero value
    return on_status + off_status
end

"""
    _update_solution!(
        solution::OrderedDict,
        sub_solution::OrderedDict,
        time_increment::Int,
    )

Updates the solution (of each scenario) by concatenating the first bunch of 
time slots of the newly generated sub-solution to the end of the final solution dictionary.
This function traverses through the dictionary keys, finds the vector and finally
does the concatenation. For now, the function is hardcoded to traverse at most 3 layers
of depth until it finds a vector object.
"""
function _update_solution!(
    solution::OrderedDict,
    sub_solution::OrderedDict,
    time_increment::Int,
)
    # the solution has at most 3 layers
    for (l1_k, l1_v) in sub_solution
        for (l2_k, l2_v) in l1_v
            if l2_v isa Array
                # slice the sub_solution
                values_of_interest = l2_v[1:time_increment]
                sub_solution[l1_k][l2_k] = values_of_interest
                # append to the solution
                if !isempty(solution)
                    append!(solution[l1_k][l2_k], values_of_interest)
                end
            elseif l2_v isa OrderedDict
                for (l3_k, l3_v) in l2_v
                    # slice the sub_solution
                    values_of_interest = l3_v[1:time_increment]
                    sub_solution[l1_k][l2_k][l3_k] = values_of_interest
                    # append to the solution
                    if !isempty(solution)
                        append!(solution[l1_k][l2_k][l3_k], values_of_interest)
                    end
                end
            end
        end
    end

    # if solution is never initialized, deep copy the sliced sub_solution
    if isempty(solution)
        merge!(solution, sub_solution)
    end
end