using System;
using System.Collections.Generic;
using System.Linq;
using Optimizer;
using Optimizer.Objects;
using static Optimizer.Objects.Utils;

namespace XPRSexamples
{
    /// <summary>A craftsman makes small wooden boxes for sale.</summary>
    /// <remarks>
    /// He has four different shapes or styles of box, and can make each
    /// of them in any size (keeping all the dimensions in proportion).
    /// The profit he makes on a box depends on the size.
    /// He has only a limited amount of the necessary wood available and a
    /// limited amount of time in the week to do the work.
    /// How many boxes should he make, and what size should they be,
    /// in order to maximize his profit?
    /// This example illustrates how to state non-linear constraints.
    /// </remarks>
    internal class Boxes02
    {
        /// <summary>A box.</summary>
        public sealed class Box
        {
            /// <summary>The name of this box.</summary>
            public readonly string Name;
            /// <summary>Relative length of this box.</summary>
            public readonly double LengthCoeff;
            /// <summary>Relative width of this box.</summary>
            public readonly double WidthCoeff;
            /// <summary>Relative height of this box.</summary>
            public readonly double HeightCoeff;
            /// <summary>Coefficient for the profit of this box, relative to its size.</summary>
            public readonly double ProfitCoeff;
            /// <summary>Coefficient for the production time of this box, relative to its ply.</summary>
            public readonly double TimeCoeff;

            public Box(string name, double lengthCoeff, double widthCoeff, double heightCoeff, double profitCoeff,
                    double timeCoeff)
            {
                this.Name = name;
                this.LengthCoeff = lengthCoeff;
                this.WidthCoeff = widthCoeff;
                this.HeightCoeff = heightCoeff;
                this.ProfitCoeff = profitCoeff;
                this.TimeCoeff = timeCoeff;
            }

            public override string ToString()
            {
                return Name;
            }
        }

        /// <summary>The boxes used in this example.</summary>
        private static readonly Box[] boxArray = new Box[] { new Box("Cube", 1, 1, 1, 20, 1),
            new Box("Oblong", 1, 2, 1, 27.3, 1), new Box("Flat", 4, 4, 1, 90, 1),
            new Box("Economy", 1, 2, 1, 10, 0.2) };

        // The resource constraints used in this example.
        const double maxSize = 2.0;
        const int maxNumProduced = 6;
        const double maxBattens = 200.0;
        const double maxPly = 210.0;
        const double maxMakeTime = 35.0;

        public static void Main(string[] args)
        {
            using (XpressProblem prob = new XpressProblem())
            {
                // Output all messages.
                prob.callbacks.AddMessageCallback(DefaultMessageListener.Console);

                /**** VARIABLES ****/

                // the number of each of the boxes that should be produced
                Variable[] numProduced = prob.AddVariables(boxArray.Length)
                        .WithName(i => $"numProduced_{i}")
                        .WithType(ColumnType.Integer)
                        .WithUB(maxNumProduced)
                        .ToArray();

                // the relative size (a factor of length/width/height) of each of the boxes that
                // should be produced
                Variable[] size = prob.AddVariables(boxArray.Length)
                        .WithName(i => $"size_{i}")
                        .WithUB(maxSize)
                        .ToArray();

                // objective transfer column
                Variable objcol = prob.AddVariable(XPRS.MINUSINFINITY, XPRS.PLUSINFINITY,
                        ColumnType.Continuous, "objCol");

                // some general characteristics of the produced boxes that will be used in the
                // model
                Expression[] battens = new Expression[boxArray.Length];
                Expression[] ply = new Expression[boxArray.Length];
                Expression[] profit = new Expression[boxArray.Length];
                Expression[] makeTime = new Expression[boxArray.Length];

                for (int i = 0; i < boxArray.Length; ++i)
                {
                    // battens = 4 * (lengthCoeff + widhtCoeff + heightCoeff) * size
                    Box b = boxArray[i];
                    battens[i] = size[i] * (4.0 * (b.LengthCoeff + b.WidthCoeff + b.HeightCoeff));
                    // ply = 2 * (lengthCoeff * widthCoeff + widthC * heightC + heightC * lengthC) *
                    // size^2
                    ply[i] = Pow(size[i], 2.0) *
                            2.0 * (b.LengthCoeff * b.WidthCoeff
                                    + b.WidthCoeff * b.HeightCoeff
                                    + b.HeightCoeff * b.LengthCoeff);
                    // profit = profitCoeff * size^1.5
                    profit[i] = b.ProfitCoeff * Pow(size[i], 1.5);
                    // makeTime = 1 + timeCoeff * 1.5^(ply/10)
                    makeTime[i] = 1.0 + b.TimeCoeff * Pow(1.5, ply[i] / 10.0);
                }

                // objective function: sum(boxes) numProduced[box] * profit[box]
                Expression totalProfit = Sum(boxArray.Length, i => numProduced[i] * profit[i]);

                // To make the objective linear, just maximize the objcol
                prob.SetObjective(objcol, ObjSense.Maximize);

                // Add the objective transfer row: objcol = totalProfit
                prob.AddConstraint(objcol == totalProfit);

                // limits on resource availability
                // sum of battens of all produced boxes <= maxBattens
                prob.AddConstraint(Sum(boxArray.Length, i => numProduced[i] * battens[i]) <= maxBattens);
                // sum of ply of all produced boxes <= maxPly
                prob.AddConstraint(Sum(boxArray.Length, i => numProduced[i] * ply[i]) <= maxPly);
                // sum of make time of all produced boxes <= maxMakeTime
                prob.AddConstraint(Sum(boxArray.Length, i => numProduced[i] * makeTime[i]) <= maxMakeTime);

                // Dump the problem to disk so that we can inspect it.
                prob.WriteProb("boxes02.lp");

                // By default we will solve to global optimality, uncomment for an MISLP solve
                // to local optimality
                // prob.controls().setNLPSolver(XPRSconstants.NLPSOLVER_LOCAL);

                // Solve
                prob.Optimize();
                if (prob.SolStatus != SolStatus.Optimal && prob.SolStatus != SolStatus.Feasible)
                    throw new Exception($"optimization failed with status {prob.SolStatus}");
                double[] sol = prob.GetSolution();
                Console.WriteLine($"Objective: {prob.ObjVal}");
                // Print out the solution
                for (int i = 0; i < boxArray.Length; ++i)
                {
                    if (numProduced[i].GetValue(sol) > 0.0)
                    {
                        Console.WriteLine($"Producing {numProduced[i].GetValue(sol)} {boxArray[i].ToString()} boxes of size {size[i].GetValue(sol)}.");
                    }
                }
            }
        }
    }
}