// Copyright (C) Stichting Deltares 2017. All rights reserved.
//
// This file is part of the DAM Engine.
//
// The DAM Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;

namespace Deltares.DamEngine.Calculators.Dikes_Operational
{
    /// <summary>
    /// Except for Dupuit calculation
    /// </summary>
    public class DupuitCalculatorException : ApplicationException
    {
        public DupuitCalculatorException(string message) : base(message)
        {
        }
    }

    /// <summary>
    /// How to call the Dupuit Calculation
    /// </summary>
    public enum DupuitCalculationType
    {
        ViaExeAndFiles,
        ViaDllAndFiles,
        ViaDllAndMemory,
    }


    /// <summary>
    /// The Dupuit Calculator
    /// </summary>
    public class DupuitCalculator
    {

        const string cDefaultDupuitProgramFullFilename = ".\\Dupuit\\DikeFlow.exe";
        private string dupuitProgramFullFilename = "";

        private DupuitCalculationType dupuitCalculationType = DupuitCalculationType.ViaDllAndFiles; 

        public string DupuitProgramFullFilename
        {
            get { return dupuitProgramFullFilename; }
            set { dupuitProgramFullFilename = value; }
        }

        /// <summary>
        /// Gets or sets the type of the dupuit calculation.
        /// </summary>
        /// <value>
        /// The type of the dupuit calculation.
        /// </value>
        public DupuitCalculationType DupuitCalculationType
        {
            get { return dupuitCalculationType; }
            set { dupuitCalculationType = value; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public DupuitCalculator()
        {
            DupuitProgramFullFilename = cDefaultDupuitProgramFullFilename;
            if (!File.Exists(dupuitProgramFullFilename))
            {
                throw new DupuitCalculatorException(String.Format("Executable '{0}' not found", dupuitProgramFullFilename));
            }
        }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="dupuitProgramFullFilename"></param>
        public DupuitCalculator(string dupuitProgramFullFilename)
        {
            DupuitProgramFullFilename = dupuitProgramFullFilename;
            if (!File.Exists(dupuitProgramFullFilename))
            {
                throw new DupuitCalculatorException(String.Format("Executable '{0}' not found", dupuitProgramFullFilename));
            }
        }

        /// <summary>
        /// Perform the Dupuit calculation by calling the external program
        /// </summary>
        /// <param name="fullFilename">The full filename.</param>
        public void Calculate(string fullFilename)
        {
            switch (DupuitCalculationType)
            {
                case DupuitCalculationType.ViaExeAndFiles:
                    CalculateViaExe(fullFilename);
                    break;
                case DupuitCalculationType.ViaDllAndFiles:
                    CalculateViaDll(fullFilename);
                    break;
                case DupuitCalculationType.ViaDllAndMemory:
                    CalculateViaDllAndMemory(fullFilename); 
                    break;
                default:
                    throw new DupuitCalculatorException(String.Format("Not implemented Dupuitcalculation type: '{0}'", DupuitCalculationType));
            }
        }

        /// <summary>
        /// Perform the Dupuit calculation by calling the DLL
        /// </summary>
        /// <param name="fullFilename">The full filename.</param>
        private void CalculateViaDll(string fullFilename)
        {
//            var dWrap = new dupuitWrapper();
//            int handle = dWrap.CreateDupuitHandle();
//            dWrap.setDupuit(handle, fullFilename);
//            dWrap.initialize(handle, fullFilename);
//            int result;
//            do
//            {
//                result = dWrap.calculateTransient(handle, fullFilename);
//            } while (result > 0); ##Bka
        }

        /// <summary>
        /// Perform the Dupuit calculation by calling the DLL
        /// </summary>
        /// <param name="fullFilename">The full filename.</param>
        private void CalculateViaDllAndMemory(string fullFilename)
        {
//            var dWrap = new dupuitWrapper();
//            int handle = dWrap.CreateDupuitHandle();
//            int result = 1;
//            do
//            {
//                result = dWrap.calculateTransient(handle, fullFilename);
//            } while (result > 0); ##Bka
        }

        /// <summary>
        /// Perform the Dupuit calculation by calling the external program
        /// </summary>
        /// <param name="fullFilename">The full filename.</param>
        /// <exception cref="DupuitCalculatorException">
        /// </exception>
        private void CalculateViaExe(string fullFilename)
        {
            Validate(fullFilename);
            const string quote = "\"";
            string argument = quote + fullFilename + quote;
            var process = new Process
            {
                StartInfo =
                {
                    FileName = DupuitProgramFullFilename,
                    Arguments = argument,
                    UseShellExecute = false
                }

            };
            try
            {
                process.Start();
            }
            catch (Win32Exception w)
            {
                throw new DupuitCalculatorException(String.Format("DikeFlow error {0}", w.Message));
            }
            process.WaitForExit();
            if (process.ExitCode != 0)
            {
                throw new DupuitCalculatorException(String.Format("DikeFlow error {0}", process.ExitCode));
            }
        }

        /// <summary>
        /// Write file with the geometry
        /// </summary>
        public void WriteSoilLayersFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Write file with the timeseries of waterlevels
        /// </summary>
        public void WriteWaterLevelFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Write file with precipitation
        /// Not used yet so always write no precipitation
        /// </summary>
        public void WritePrecipitationFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Write file with material properties
        /// </summary>
        public void WriteMaterialFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Write file with monitoring 
        /// Not used yet so always write empty file
        /// </summary>
        public void WriteMonitorFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Write file with characteristic points
        /// </summary>
        public void WriteSectionsFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Write file with calculation options
        /// </summary>
        public void WriteCalculateFile()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Read all piezolines (pllines) for all timesteps
        /// </summary>
        public void ReadPiezoLinesFiles()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Throw an exception if object undefined
        /// </summary>
        /// <param name="argument"></param>
        /// <param name="objectName"></param>
        private void ThrowIfArgumentNull(Object argument, string objectName)
        {
            if (argument == null)
            {
                throw new DupuitCalculatorException(String.Format("Missing input: '{0}' not defined", objectName));
            }
        }

        /// <summary>
        /// Throw an exception if string undefined
        /// </summary>
        /// <param name="argument"></param>
        /// <param name="stringName"></param>
        private void ThrowIfStringIsEmpty(string argument, string stringName)
        {
            if (argument.Equals(""))
            {
                throw new DupuitCalculatorException(String.Format("Missing input: '{0}' not defined", stringName));
            }
        }

        private void ThrowIfFileNotExists(string fullFilename)
        {
            if (!File.Exists(fullFilename))
            {
                throw new DupuitCalculatorException(String.Format("Missing file: '{0}'", fullFilename));
            }
        }

        /// <summary>
        /// Validate if calculation can be made
        /// </summary>
        private void Validate(string fullFilename)
        {
            ThrowIfStringIsEmpty(dupuitProgramFullFilename, "dupuitProgramFullFilename");
            string baseFilename = Path.GetFullPath(fullFilename);
            ThrowIfFileNotExists(dupuitProgramFullFilename);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.soilLayersFilenameExt);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.waterLevelFilenameExt);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.precipitationFilenameExt);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.materialFilenameExt);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.monitorFilenameExt);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.sectionsFilenameExt);
//            ThrowIfFileNotExists(baseFilename + DupuitCalculatorFileIO.calculateFilenameExt);  ##Bka
        }
    }
}