using System;
using MathWorks.MATLAB.Runtime;
using MathWorks.MATLAB.Types;
using CellStats;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            string ctfPath = @"CellStats.ctf";

       /*
        * If the direct path to the .ctf file does not work, import the 
	* following namespaces and use the following code to construct the 
	* path dynamically:
        * 
        * using System.IO;
        * using System.Reflection;
        * 
        * // Get the directory of the executing assembly
        * string assemblyPath = Assembly.GetExecutingAssembly().Location;
        * string assemblyDirectory = Path.GetDirectoryName(assemblyPath);
        *
        * // Construct the path to the .ctf file
        * string ctfPath = Path.Combine(assemblyDirectory, "CellStats.ctf");
        */

            using (dynamic matlab = MATLABRuntime.StartMATLAB(ctfPath))
            {
                // define the input cell: you need to use System.Object[,] for the cell
                var inputCell = new System.Object[,]
                {
                    { "temperatures", new double[] { 72, 75, 69, 68, 70 } },
                    { "pressures", new double[] { 30, 29.5, 30.2, 29.9, 30.1 } }
                };

                // define the output cell: you need to use System.Object[,] for the cell
                var outputCell = new System.Object[2, 3];
                // Use the computeCellMean method
                MATLABFunctions.computeCellMean(matlab, inputCell, out outputCell);

                // create a list of tuples to hold the output cell
                // conversion to a list of tuples is not necessary but it helps maintain the 
                // shape of the output from the MATLAB function computeCellMean
                var outputCellAsListOfTuples = new List<(string s, double[] vector, double scalar)>();

                // row # 1
                outputCellAsListOfTuples.Add(
                            (outputCell[0, 0] as dynamic, outputCell[0, 1] as dynamic, outputCell[0, 2] as dynamic));
                // row # 2
                outputCellAsListOfTuples.Add(
                            (outputCell[1, 0] as dynamic, outputCell[1, 1] as dynamic, outputCell[1, 2] as dynamic));

                Console.WriteLine("INPUT");
                PrintObjectAsMatrix(inputCell);
                Console.WriteLine("");
                Console.WriteLine("OUTPUT");
                PrintCellListAsMatrix(outputCellAsListOfTuples);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
    public static void PrintCellListAsMatrix(List<(string cellString, double[] cellArray, double cellDouble)> cellList)
    {
        // Calculate the maximum width required for the array column
        int maxArrayWidth = 
                cellList.Max(cell => "[" + string.Join(", ", cell.cellArray.Select(d => d.ToString("F2"))) + "]").Length;

        // Calculate the maximum width required for the double column
        int maxDoubleWidth = cellList.Max(cell => cell.cellDouble.ToString("F2").Length);

        foreach (var cell in cellList)
        {
            // Format the string
            string formattedString = cell.cellString.PadRight(30); // Adjust the padding as necessary

            // Format the array and use maxArrayWidth for uniform padding
            string formattedArray = 
                   "[" + string.Join(", ", cell.cellArray.Select(d => d.ToString("F2"))) + "]".PadRight(maxArrayWidth + 5); 

            // Format the double and use maxDoubleWidth for uniform padding
            string formattedDouble = cell.cellDouble.ToString("F2").PadRight(maxDoubleWidth + 5); 

            // Print the formatted row
            Console.WriteLine($"{formattedString}{formattedArray}{formattedDouble}");
        }
    }
    public static void PrintObjectAsMatrix(System.Object[,] matrix)
    {
        int maxLabelWidth = GetMaxWidth(matrix, 0);
        int maxArrayWidth = GetMaxWidth(matrix, 1, true);

        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            string label = matrix[i, 0] as string;
            if (label == null) continue; // Skip if the conversion fails

            label = label.PadRight(maxLabelWidth + 5);

            var values = matrix[i, 1] as double[];
            if (values == null) continue; // Skip if the conversion fails

            string formattedArray = 
                   "[" + string.Join(", ", values.Select(d => d.ToString("F2"))) + "]".PadRight(maxArrayWidth + 5);

            Console.WriteLine($"{label}{formattedArray}");
        }
    }
    private static int GetMaxWidth(System.Object[,] matrix, int columnIndex, bool isDoubleArray = false)
    {
        int maxWidth = 0;
        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            if (isDoubleArray)
            {
                var values = matrix[i, columnIndex] as double[];
                if (values == null) continue; // Skip if the conversion fails

                int width = ("[" + string.Join(", ", values.Select(d => d.ToString("F2"))) + "]").Length;
                maxWidth = Math.Max(maxWidth, width);
            }
            else
            {
                string value = matrix[i, columnIndex] as string;
                if (value == null) continue; // Skip if the conversion fails

                maxWidth = Math.Max(maxWidth, value.Length);
            }
        }
        return maxWidth;
    }

}