using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;

namespace DTS.Slice.PedestrianAndHeadReports
{
    public class HeadReport : ReportBase
    {
        public HeadReport(PedestrianAndHeadTest parent)
            : base(parent) { }

        public const string HEAD_X_ChannelID = "HEAD_X";
        public const string HEAD_Y_ChannelID = "HEAD_Y";
        public const string HEAD_Z_ChannelID = "HEAD_Z";
        public const string HEAD_Displacement = "HEAD_DISPLACEMENT";
        public const string HEAD_RESULTANT_CHANNELID = "HEAD_RESULTANT";
        protected override void InitializeGraphs()
        {
            base.InitializeGraphs();
            AddGraph(new ReportGraph(KnownGraphs.HEAD_Acceleration.ToString(), "Acceleration", new MeasurementUnit []  { 
                MeasurementUnitList.GetMeasurementUnit("m/sec^2"), MeasurementUnitList.GetMeasurementUnit("G") 
            }, new GraphChannel[]{
                new GraphChannel(HEAD_X_ChannelID, "X軸加速度", "X"),
                new GraphChannel(HEAD_Y_ChannelID, "Y軸加速度", "Y"),
                new GraphChannel(HEAD_Z_ChannelID, "Z軸加速度", "Z")
            }, Properties.Settings.Default.PROTECTIONREPORT_HEADACCEL_Threshold));
            AddGraph(new ReportGraph(KnownGraphs.HEAD_ResultantAcceleration.ToString(), "Resultant", new MeasurementUnit[] {
                MeasurementUnitList.GetMeasurementUnit("m/sec^2")
            }, new GraphChannel[] {
                new HICChannel(HEAD_RESULTANT_CHANNELID, "Acceleration", "Acceleration Resultant")
            }, Properties.Settings.Default.PROTECTIONREPORT_HEADRESULTANT_Threshold));
            AddGraph(new ReportGraph(KnownGraphs.HEAD_StrokeDisplacement.ToString(), "Displacement", new MeasurementUnit[] { 
                MeasurementUnitList.GetMeasurementUnit("mm")}, new GraphChannel[] {
                new GraphChannel(HEAD_Displacement, "Displacement", "HEAD Displacement")}, ""));
        }
        
        public override ReportBase.ReportTypes GetReportType()
        {
            return ReportTypes.Head;
        }

        public string ClassificationAngle
        {
            get { return GetValue(PedestrianAndHeadTest.Fields.ClassificationAngle.ToString()); }
            set { SetValue(PedestrianAndHeadTest.Fields.ClassificationAngle.ToString(), value); }
        }
        protected override void InitializeProperties()
        {
            base.InitializeProperties();
            SetPossibleValues(PedestrianAndHeadTest.Fields.ImpactorType.ToString(), new string[] { "ADULT", "CHILD" });
            SetValue(PedestrianAndHeadTest.Fields.ImpactorType.ToString(), "ADULT");
            SetValue(PedestrianAndHeadTest.Fields.FrequencyClass.ToString(), (new SensorDB.FilterClass(DTS.SensorDB.FilterClass.FilterClassType.CFC1000)).ToString());
            AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.ClassificationAngle.ToString(), "Classification angle", null, typeof(string)));
        }
        
        public override void DrawGraph(KnownGraphs graph, C1.Win.C1Chart.C1Chart chart)
        {
            switch (graph)
            {
                case KnownGraphs.HEAD_ResultantAcceleration:
                    {
                        var channelX = GetChannel(KnownGraphs.HEAD_Acceleration, HEAD_X_ChannelID);
                        var channelY = GetChannel(KnownGraphs.HEAD_Acceleration, HEAD_Y_ChannelID);
                        var channelZ = GetChannel(KnownGraphs.HEAD_Acceleration, HEAD_Z_ChannelID);


                        
                        if (null == channelX || null == channelZ || null == channelY
                            || null == channelX.Channel || null == channelY.Channel || null == channelZ.Channel) { return; }
                        try
                        {
                            string euX = (channelX.Channel as DTS.DAS.Concepts.DAS.Channel.IEngineeringUnitAware).EngineeringUnits;
                            string euY = (channelY.Channel as DTS.DAS.Concepts.DAS.Channel.IEngineeringUnitAware).EngineeringUnits;
                            string euZ = (channelZ.Channel as DTS.DAS.Concepts.DAS.Channel.IEngineeringUnitAware).EngineeringUnits;
                            System.Diagnostics.Trace.Assert(euX == euY && euY == euZ);
                            //string units = GetUnits(KnownGraphs.HEAD_Acceleration);
                            var x = new DTS.Calculations.ChannelData(euX);
                            x.FilteredEU = channelX.Channel.DataEu.ToArray();

                            var y = new DTS.Calculations.ChannelData(euY);
                            y.FilteredEU = channelY.Channel.DataEu.ToArray();

                            var z = new DTS.Calculations.ChannelData(euZ);
                            z.FilteredEU = channelZ.Channel.DataEu.ToArray();

                            if (euX.Trim().ToLower() != "g")
                            {
                                double scale = ReportGraph.GetScaleFactor("G", euX);
                                for (int i = 0; i < x.FilteredEU.Length; i++)
                                {
                                    x.FilteredEU[i] *= scale;
                                    y.FilteredEU[i] *= scale;
                                    z.FilteredEU[i] *= scale;
                                }
                            }
                            var res = DTS.Calculations.Resultant.GenerateResultantChannel(new List<DTS.Calculations.ChannelData>() { x, y, z });
                            var hicResult = DTS.Calculations.HeadInjuryCriterion.GetHeadInjuryCriterion(res, channelX.Channel.ParentModule.SampleRateHz,
                                15);
                            DTS.Slice.Control.Event.Module.Channel.HICCalculatedChannel cc = new DTS.Slice.Control.Event.Module.Channel.HICCalculatedChannel(
                                "HIC", DTS.Slice.Control.Event.Module.Channel.CalculatedChannel.XUnits.msec, "G", 
                                new double [0], res.FilteredEU, DTS.Slice.Control.Event.Module.Channel.CalculatedChannel.Operation.HeadInjuryCriteria,
                                0, channelX.Channel.ParentModule, hicResult);
                           
                            ReviewTestChannel rtc = new ReviewTestChannel(cc, channelX.ParentTest);
                            var g = GetGraph(ReportBase.KnownGraphs.HEAD_ResultantAcceleration.ToString());
                            g.SetReviewTestChannel(HEAD_RESULTANT_CHANNELID, rtc);
                            GraphChannel c = g.GetGraphChannel(HEAD_RESULTANT_CHANNELID);
                            HICChannel hicChannel = c as HICChannel;
                            hicChannel.HIC = hicResult.HIC;

                            hicChannel.T1 = cc.GetT1("ms" == g.TimeUnits);
                            hicChannel.T2 = cc.GetT2("ms" == g.TimeUnits);
                        }
                        catch (System.Exception) { }
                        base.DrawGraph(graph, chart);
                    }
                    break;
                default:
                    base.DrawGraph(graph, chart);
                    break;
            }       
        }
    }
}