//-----------------------------------------------------------------------
// <copyright file="DupuitCalculator.cs" company="Deltares">
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>20-05-2011</date>
// <summary>Contains class to interact with external Dupuit calcualtion program</summary>
//-----------------------------------------------------------------------
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using Deltares.Dupuit;

namespace Deltares.Dam.Data
{
    using System;

    /// <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 Deltares.Dam.Data.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);
        }

        /// <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);
        }

        /// <summary>
        /// Perform the Dupuit calculation by calling the external program
        /// </summary>
        /// <param name="fullFilename">The full filename.</param>
        /// <exception cref="Deltares.Dam.Data.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);
        }
    }
}