using System;
using System.Linq;
using System.Data;
using System.IO;

namespace DTS.Reports
{
    public class DiagnosticsReport : ReportBase
    {
        private enum DASFields
        {
            DAS,
            FW,
            CalDate,
            DueDate,
            Connection,
            Input,
            Battery
        }
        private enum AnalogFields
        {
            ExportNum,
            DAS,
            Module,
            Channel,
            Object,
            Sens,
            Desc,
            Exc,
            Offset,
            Shunt,
            Range,
            Noise
        }
        private enum SquibFields
        {
            DAS,
            Module,
            Channel,
            Desc,
            ISO,
            FireMode,
            Delay,
            Duration
        }
        public class AnalogHelper
        {
            public enum ResultStatus
            {
                Passed,
                Failed,
                NotTested
            }
            public int ExportNum { get; set; }
            public string DAS { get; set; }
            public string Module { get; set; }
            public string Channel { get; set; }
            public string Object { get; set; }
            public string SensorSerialNumber { get; set; }
            public string SerialNumberWithAxis { get; set; }
            public string Desc { get; set; }
            public double ScalefactorMilliVoltsPerADC { get; set; }
            public double ActualRangeMv { get; set; }
            public double Exc { get; set; }
            public ResultStatus ExcStatus { get; set; }
            public double Offset { get; set; }
            public ResultStatus OffStatus { get; set; }
            public double Shunt { get; set; }
            public ResultStatus ShuntStatus { get; set; }
            public double Range { get; set; }
            public ResultStatus RangeStatus { get; set; }
            public double Noise { get; set; }
            public ResultStatus NoiseStatus { get; set; }
        }
        public class DASHelper
        {
            public string DAS { get; set; }
            public string Firmware { get; set; }
            public DateTime CalDate { get; set; }
            public DateTime DueDate { get; set; }
            public string Connection { get; set; }
            public string Input { get; set; }
            public string Battery { get; set; }
        }
        public class SquibHelper
        {
            public enum ResultStatus
            {
                Passed,
                Failed,
                NotTested
            }
            public string DAS { get; set; }
            public string Module { get; set; }
            public string Channel { get; set; }
            public string Desc { get; set; }
            public string ISO { get; set; }
            public string FireMode { get; set; }
            public double Delay { get; set; }
            public ResultStatus DelayStatus { get; set; }
            public double Duration { get; set; }
            public ResultStatus DurationStatus { get; set; }
            public double Resistance { get; set; }
        }
        public DiagnosticsReport()
        {

        }


        public static string GetReportFilename(bool isPreTest, string testId)
        {
            if (false == string.IsNullOrEmpty(testId))
            {
                return isPreTest
                    ? $"{testId} Pretest Diagnostics {GetFilenameTimeStamp()}.xlsx"
                    : $"{testId} Post-Test Diagnostics {GetFilenameTimeStamp()}.xlsx";
            }
            else
            {
                // Return the template filename
                return "Diagnostic Results.xlsx";
            }
        }

        public static string GetReportFilenamePath(bool isPreTest, string reportPath, string testId)
        {
            var filename = GetReportFilename(isPreTest, testId);
            return Path.Combine(reportPath, filename);
        }

        public void DoReport(DASHelper[] das, AnalogHelper[] analog, SquibHelper[] squib, string outputFileName, string folderNameId, string sensitivityDisplayFormat,
            bool generateExcelReports, bool generatePDFReports)
        {
            var dtDAS = new DataTable();
            var dtAnalog = new DataTable();
            var dtSquib = new DataTable();
            var dtAnalogStyles = new DataTable();
            var dtSquibStyles = new DataTable();
            var minDate = new DateTime(1970, 1, 1);

            try
            {
                dtAnalog.TableName = "Analog";
                dtDAS.TableName = "DAS";
                dtSquib.TableName = "Squibs";

                var analogFields = Enum.GetValues(typeof(AnalogFields)).Cast<AnalogFields>().ToArray();
                foreach (var field in analogFields)
                {
                    var c = dtAnalog.Columns.Add(field.ToString());
                    var c2 = dtAnalogStyles.Columns.Add(field.ToString(), typeof(int));
                    switch (field)
                    {
                        case AnalogFields.Channel: c.DataType = typeof(string); break;
                        case AnalogFields.DAS: c.DataType = typeof(string); break;
                        case AnalogFields.Desc: c.DataType = typeof(string); break;
                        case AnalogFields.Exc: c.DataType = typeof(double); break;
                        case AnalogFields.ExportNum: c.DataType = typeof(int); break;
                        case AnalogFields.Module: c.DataType = typeof(string); break;
                        case AnalogFields.Noise: c.DataType = typeof(double); break;
                        case AnalogFields.Object: c.DataType = typeof(string); break;
                        case AnalogFields.Offset: c.DataType = typeof(double); break;
                        case AnalogFields.Range: c.DataType = typeof(string); break;
                        case AnalogFields.Sens: c.DataType = typeof(string); break;
                        case AnalogFields.Shunt: c.DataType = typeof(double); break;
                    }
                }
                var dasFields = Enum.GetValues(typeof(DASFields)).Cast<DASFields>().ToArray();
                foreach (var field in dasFields)
                {
                    var c = dtDAS.Columns.Add(field.ToString());
                    switch (field)
                    {
                        case DASFields.Battery: c.DataType = typeof(string); break;
                        case DASFields.CalDate: c.DataType = typeof(string); break;
                        case DASFields.Connection: c.DataType = typeof(string); break;
                        case DASFields.DAS: c.DataType = typeof(string); break;
                        case DASFields.DueDate: c.DataType = typeof(string); break;
                        case DASFields.FW: c.DataType = typeof(string); break;
                        case DASFields.Input: c.DataType = typeof(string); break;
                    }
                }
                var squibFields = Enum.GetValues(typeof(SquibFields)).Cast<SquibFields>().ToArray();
                foreach (var field in squibFields)
                {
                    var c = dtSquib.Columns.Add(field.ToString());
                    var c2 = dtSquibStyles.Columns.Add(field.ToString(), typeof(int));
                    switch (field)
                    {
                        case SquibFields.Channel: c.DataType = typeof(string); break;
                        case SquibFields.DAS: c.DataType = typeof(string); break;
                        case SquibFields.Delay: c.DataType = typeof(double); break;
                        case SquibFields.Desc: c.DataType = typeof(string); break;
                        case SquibFields.Duration: c.DataType = typeof(double); break;
                        case SquibFields.FireMode: c.DataType = typeof(string); break;
                        case SquibFields.ISO: c.DataType = typeof(string); break;
                        case SquibFields.Module: c.DataType = typeof(string); break;
                    }
                }
                foreach (var ch in squib)
                {
                    var row = dtSquib.NewRow();
                    var row2 = dtSquibStyles.NewRow();

                    foreach (var field in squibFields)
                    {
                        object o = null;
                        row2[field.ToString()] = -1;
                        switch (field)
                        {
                            case SquibFields.Channel: o = ch.Channel; break;
                            case SquibFields.DAS: o = ch.DAS; break;
                            case SquibFields.Delay:
                                o = ch.Delay;
                                switch (ch.DelayStatus)
                                {
                                    case SquibHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                    case SquibHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case SquibHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                }
                                break;
                            case SquibFields.Desc: o = ch.Desc; break;
                            case SquibFields.Duration:
                                o = ch.Duration;
                                switch (ch.DurationStatus)
                                {
                                    case SquibHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                    case SquibHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case SquibHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                }
                                break;
                            case SquibFields.FireMode: o = ch.FireMode; break;
                            case SquibFields.ISO: o = ch.ISO; break;
                            case SquibFields.Module: o = ch.Module; break;
                        }
                        row[field.ToString()] = o;
                    }
                    dtSquib.Rows.Add(row);
                    dtSquibStyles.Rows.Add(row2);
                }
                foreach (var ch in analog)
                {
                    var row = dtAnalog.NewRow();
                    var row2 = dtAnalogStyles.NewRow();

                    foreach (var field in analogFields)
                    {
                        object o = null;
                        row2[field.ToString()] = -1;
                        switch (field)
                        {
                            case AnalogFields.Channel:
                                o = ch.Channel;
                                break;
                            case AnalogFields.DAS: o = ch.DAS; break;
                            case AnalogFields.Desc: o = ch.Desc; break;
                            case AnalogFields.Exc:
                                o = ch.Exc / 1000D;
                                switch (ch.ExcStatus)
                                {
                                    case AnalogHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                    case AnalogHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case AnalogHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                }
                                break;
                            case AnalogFields.ExportNum: o = ch.ExportNum; break;
                            case AnalogFields.Module: o = ch.Module; break;
                            case AnalogFields.Noise:
                                o = ch.Noise;
                                switch (ch.NoiseStatus)
                                {
                                    case AnalogHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                    case AnalogHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case AnalogHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                }
                                break;
                            case AnalogFields.Object: o = ch.Object; break;
                            case AnalogFields.Offset:
                                o = ch.Offset;
                                switch (ch.OffStatus)
                                {
                                    case AnalogHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                    case AnalogHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case AnalogHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                }
                                break;
                            case AnalogFields.Range:
                                if (double.IsInfinity(ch.Range))
                                {
                                    o = "Infinity";
                                }
                                else if (double.IsNaN(ch.Range))
                                {
                                    o = "---";
                                }
                                else
                                {
                                    o = string.Format("{0:0.00}", ch.Range);
                                }
                                switch (ch.RangeStatus)
                                {
                                    case AnalogHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                    case AnalogHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case AnalogHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                }
                                break;
                            case AnalogFields.Sens: o = ch.SensorSerialNumber; break;
                            case AnalogFields.Shunt:
                                o = ch.Shunt;
                                switch (ch.ShuntStatus)
                                {
                                    case AnalogHelper.ResultStatus.Failed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Fail;
                                        break;
                                    case AnalogHelper.ResultStatus.NotTested:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.NotTested;
                                        break;
                                    case AnalogHelper.ResultStatus.Passed:
                                        row2[field.ToString()] = (int)ReportBase.FillStyles.Pass;
                                        break;
                                }
                                break;
                        }
                        row[field.ToString()] = o;
                    }
                    dtAnalog.Rows.Add(row);
                    dtAnalogStyles.Rows.Add(row2);
                }
                foreach (var d in das)
                {
                    var row = dtDAS.NewRow();
                    foreach (var field in dasFields)
                    {
                        object o = null;
                        switch (field)
                        {
                            case DASFields.Battery: o = d.Battery; break;
                            case DASFields.CalDate:
                                if (d.CalDate.Year < 1970)
                                {
                                    o = "";
                                }
                                else
                                {
                                    if (d.CalDate == minDate)
                                    {
                                        o = "--";
                                    }
                                    else
                                    {
                                        o = d.CalDate.ToShortDateString();
                                    }
                                }
                                break;
                            case DASFields.Connection: o = d.Connection; break;
                            case DASFields.DAS: o = d.DAS; break;
                            case DASFields.DueDate:
                                if (d.DueDate.Year < 1970)
                                {
                                    o = "";
                                }
                                else
                                {
                                    if (d.CalDate == minDate)
                                    {
                                        o = "--";
                                    }
                                    else
                                    {
                                        o = d.DueDate.ToShortDateString();
                                    }
                                }
                                break;
                            case DASFields.FW: o = d.Firmware; break;
                            case DASFields.Input: o = d.Input; break;
                        }
                        row[field.ToString()] = o;
                    }
                    dtDAS.Rows.Add(row);
                }
                TemplateFilename = GetReportFilenamePath(false, GetTemplateReportPath(), string.Empty);
                OutputFilename = outputFileName;

                if (File.Exists(outputFileName))
                {
                    ReportFileWillBeOverwritten(outputFileName);
                    try
                    {
                        File.Delete(outputFileName);
                    }
                    catch (Exception)
                    {
                        ReportFileInUse(outputFileName);
                    }
                }

                if (generateExcelReports)
                {
                    OutputReport(new DataTable[] { dtDAS, dtAnalog, dtSquib }, new DataTable[] { null, dtAnalogStyles, dtSquibStyles });
                    CopyReportIfNeeded(folderNameId, outputFileName);
                }

                if (generatePDFReports)
                {
                    //Make a PDF with the same name
                    outputFileName = outputFileName.Replace(".xlsx", ".pdf");
                    //Don't overwrite the Excel file that may be the filled-in template.
                    DestinationTemplateFilename = OutputFilename.Replace(".xlsx", Common.Constants.TEMP_FILE_EXTENSION);
                    OutputFilename = outputFileName;
                    OutputReportPDF(new DataTable[] { dtDAS, dtAnalog, dtSquib }, new DataTable[] { null, dtAnalogStyles, dtSquibStyles }, sensitivityDisplayFormat);
                    CopyReportIfNeeded(folderNameId, outputFileName);
                }
            }
            finally
            {
                dtDAS.Dispose();
                dtAnalog.Dispose();
                dtSquib.Dispose();
            }
        }
    }
}