// (c) 2023-2024 Fair Isaac Corporation


using System;
using System.Linq;
using ColumnType = Optimizer.ColumnType;
using Optimizer;
using Optimizer.Objects;
using static Optimizer.Objects.Utils;
using static Optimizer.Objects.ConstantExpression;

namespace XpressExamples
{
    /// <summary>Recursion solving a non-linear financial planning problem</summary>
    /// <remarks>
    ///  The problem is to solve
    ///  <code>
    ///    net(t) = Payments(t)  - interest(t)
    ///    balance(t) = balance(t-1) - net(t)
    ///    interest(t) = (92/365) * balance(t) * interest_rate
    ///  where
    ///    balance(0) = 0
    ///    balance[T] = 0
    ///  for interest_rate
    ///  </code>
    /// </remarks>
    internal class RecursiveFinancialPlanning
    {
        private static readonly int T = 6;

        /* Data */
        /* An INITIAL GUESS as to interest rate x */
        private static double X = 0.00;
        /* An INITIAL GUESS as to balances b(t) */
        private static readonly double[] B = { 1, 1, 1, 1, 1, 1 };
        private static readonly double[] P = { -1000, 0, 0, 0, 0, 0 };            /* Payments */
        private static readonly double[] R = { 206.6, 206.6, 206.6, 206.6, 206.6, 0 }; /*  "  */
        private static readonly double[] V = { -2.95, 0, 0, 0, 0, 0 };                 /*  "  */

        /* Variables and constraints */
        static Variable[] b; /* Balance */
        static Variable x;               /* Interest rate */
        static Variable dx;              /* Change to x */
        static Inequality[] interest;
        static Inequality ctrd;


        private static void PrintIteration(XpressProblem prob, int it, double variation)
        {
            double[] sol = prob.GetSolution();
            Console.WriteLine("---------------- Iteration {0:d} ----------------", it);
            Console.WriteLine("Objective: {0:f2}", prob.ObjVal);
            Console.WriteLine("Variation: {0:f2}", variation);
            Console.WriteLine("x: {0:f2}", x.GetValue(sol));
            Console.WriteLine("----------------------------------------------");
        }

        private static void PrintProblemSolution(XpressProblem prob)
        {
            double[] sol = prob.GetSolution();
            Console.WriteLine("Objective: {0:f2}", prob.ObjVal);
            Console.WriteLine("Interest rate: {0:f2 percent}", x.GetValue(sol) * 100);
            Console.WriteLine("Variables:");
            Console.Write("\t");
            foreach (Variable v in prob.GetVariables())
            {
                Console.Write("[{0}: {1:f2}] ", v.GetName(), v.GetValue(sol));
            }
            Console.WriteLine();
        }

        /***********************************************************************/
        private static void ModFinNLP(XpressProblem p)
        {
            interest = new Inequality[T];
            interest = new Inequality[T];

            // Balance
            b = p.AddVariables(T)
                .WithType(ColumnType.Continuous)
                .WithName(t => $"b_{t}")
                .WithLB(Double.NegativeInfinity)
                .ToArray();

            // Interest rate
            x = p.AddVariable(
                0.0,
                Double.PositiveInfinity,
                ColumnType.Continuous,
                "x"
            );

            // Interest rate change
            dx = p.AddVariable(
                Double.NegativeInfinity,
                Double.PositiveInfinity,
                ColumnType.Continuous,
                "dx"
            );

            Variable[] i = p.AddVariables(T)
                .WithType(ColumnType.Continuous)
                .WithName(t => $"i_{t}")
                .ToArray();

            Variable[] n = p.AddVariables(T)
                .WithType(ColumnType.Continuous)
                .WithName(t => $"n_{t}")
                .WithLB(Double.NegativeInfinity)
                .ToArray();

            Variable[] epl = p.AddVariables(T)
                .WithType(ColumnType.Continuous)
                .WithName(t => $"epl_{t}")
                .ToArray();

            Variable[] emn = p.AddVariables(T)
                .WithType(ColumnType.Continuous)
                .WithName(t => $"emn_{t}")
                .ToArray();

            // Fixed variable values
            i[0].Fix(0);
            b[T - 1].Fix(0);

            // Objective
            p.SetObjective(
                Sum(
                    Sum(epl),
                    Sum(emn)
                ),
                Optimizer.ObjSense.Minimize
            );

            // Constraints
            //   net = payments - interest
            p.AddConstraints(T,
                    t => n[t].Eq(Sum(Constant(P[t] + R[t] + V[t]), -i[t])).SetName($"net_{t}")
                    );

            // Money balance across periods
            p.AddConstraints(T,
                    t => b[t].Eq(t > 0 ? b[t - 1] : Constant(0.0)).SetName($"bal_{t}")
                    );

            // i(t) = (92/365)*( b(t-1)*X + B(t-1)*dx ) approx.
            foreach (int t in Enumerable.Range(1, T - 1))
            {
                LinExpression iepx = new LinTermMap();
                iepx.AddTerm(X * b[t - 1]);
                iepx.AddTerm(B[t - 1] * dx);
                iepx.AddTerm(epl[t]);
                iepx.AddTerm(emn[t]);
                interest[t] = p.AddConstraint(i[t] * (365 / 92.0) == iepx).SetName($"int_{t}");
            }

            // x = dx + X
            ctrd = p.AddConstraint(x == Sum(dx, Constant(X))).SetName("def");
            p.WriteProb("Recur.lp", "l");
        }

        /**************************************************************************/
        /*  Recursion loop (repeat until variation of x converges to 0):          */
        /*    save the current basis and the solutions for variables b[t] and x   */
        /*    set the balance estimates B[t] to the value of b[t]                 */
        /*    set the interest rate estimate X to the value of x                  */
        /*    reload the problem and the saved basis                              */
        /*    solve the LP and calculate the variation of x                       */
        /**************************************************************************/
        private static void solveFinNLP(XpressProblem p)
        {
            double variation = 1.0;

            // Switch automatic cut generation off
            p.CutStrategy = (int)Optimizer.CutStrategy.None;
            // Solve the LP-problem
            p.LpOptimize();
            if (p.SolStatus != Optimizer.SolStatus.Optimal)
                throw new Exception("failed to optimize with status " + p.SolStatus);

            for (int it = 1; variation > 1e-6; ++it)
            {
                // Optimization solution
                double[] sol = p.GetSolution();

                PrintIteration(p, it, variation);
                PrintProblemSolution(p);
                // Change coefficients in interest[t]
                // Note: when inequalities are added to a problem then all variables are moved to
                // the left-hand side and all constants are moved to the right-hand side. Since we
                // are changing these extracted inequalities directly, we have to use negative
                // coefficients below.
                foreach (int t in Enumerable.Range(1, T - 1))
                {
                    p.ChgCoef(interest[t], dx, -b[t - 1].GetValue(sol));
                    p.ChgCoef(interest[t], b[t - 1], -x.GetValue(sol));
                }

                // Change constant term of ctrd
                ctrd.SetRhs(x.GetValue(sol));

                // Solve the LP-problem
                p.LpOptimize();
                double[] newsol = p.GetSolution();
                if (p.SolStatus != Optimizer.SolStatus.Optimal)
                    throw new Exception("failed to optimize with status " + p.SolStatus);
                variation = Math.Abs(x.GetValue(newsol) - x.GetValue(sol));
            }
            PrintProblemSolution(p);
        }

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

                ModFinNLP(prob);
                solveFinNLP(prob);
            }
        }
    }
}