using System.Collections.Generic;
using System.Data;
using Deltares.DamEngine.Calculators.KernelWrappers.Common;
using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamPiping.BlighCalculator;

namespace Deltares.DamEngine.Calculators.KernelWrappers.DamPipingBligh
{
    public class DamPipingBlighKernelWrapper : IKernelWrapper
    {

        public IKernelDataInput Prepare(DamKernelInput damKernelInput)
        {
            // TODO: this is just fake data
            return new DamPipingBlighInput()
            {
                HRiver = 2.0,
                HExit = 0.0,
                Rc = 0.3,
                DTotal = 5.0,
                SeepageLength = 40.5,
                D70 = 180.0
            };
        }

        public int Validate(IKernelDataInput kernelDataInput, out List<LogMessage> messages)
        {
            var calculatorBligh = PipingCalculatorBligh(kernelDataInput);
            List<string> kernelMessages = calculatorBligh.Validate();
            messages = new List<LogMessage>();
            foreach (string stringMessage in kernelMessages)
            {
                messages.Add(new LogMessage() {Message = stringMessage , MessageType = LogMessageType.Error});
            }
            return messages.Count;
        }

        public IKernelDataOutput Execute(IKernelDataInput kernelDataInput, out List<LogMessage> messages)
        {
            var calculatorBligh = PipingCalculatorBligh(kernelDataInput);
            calculatorBligh.Calculate();
            var damPipingBlighOutput = new DamPipingBlighOutput();
            damPipingBlighOutput.FoSp = calculatorBligh.FoSp;
            damPipingBlighOutput.Hc = calculatorBligh.Hc;
            messages = new List<LogMessage>();
            return damPipingBlighOutput;
        }

        private static PipingCalculatorBligh PipingCalculatorBligh(IKernelDataInput kernelDataInput)
        {
            DamPipingBlighInput damPipingBlighInput = kernelDataInput as DamPipingBlighInput;
            if (damPipingBlighInput == null)
            {
                throw new NoNullAllowedException("No input object defined for Bligh");
            }
            var calculator = new PipingCalculatorBligh
            {
                HRiver = damPipingBlighInput.HRiver,
                HExit = damPipingBlighInput.HExit,
                Rc = damPipingBlighInput.Rc,
                DTotal = damPipingBlighInput.DTotal,
                SeepageLength = damPipingBlighInput.SeepageLength,
                D70 = damPipingBlighInput.D70
            };
            return calculator;
        }

        public void PostProcess(IKernelDataOutput kernelDataOutput, out DesignResult designResult)
        {
            DamPipingBlighOutput damPipingBlighOutput = kernelDataOutput as DamPipingBlighOutput;
            if (damPipingBlighOutput == null)
            {
                throw new NoNullAllowedException("No output object defined for Bligh");
            }
            string id = "id";
            string soilProfile2DName = "soilProfile2DName";
            var d = new DamFailureMechanismeCalculationSpecification();
            var s = new DesignScenario();
            var p = new SoilProfile1D();

            designResult = new DesignResult(id, d, s, p, soilProfile2DName, AnalysisType.NoAdaption,0);
            var pipingDesignResults = new PipingDesignResults(PipingModelType.Bligh);
            pipingDesignResults.BlighFactor = damPipingBlighOutput.FoSp;
            pipingDesignResults.BlighHcritical = damPipingBlighOutput.Hc;
            designResult.PipingDesignResults = pipingDesignResults;
        }

    }
}