using DTS.Common.Enums;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Enums.Sensors;
using DTS.Common.Enums.Viewer;
using DTS.Common.Interface.ISO.ExtraProperties;
using DTS.Common.Interface.RegionOfInterest;
using System;
using System.Collections.Generic;
using System.ComponentModel;

namespace DTS.Common.Interface.TestSetups.TestSetupsList
{
    /// <summary>
    /// Describes a test setup record in the database
    /// </summary>
    public interface ITestSetupRecord
    {
        /// <summary>
        /// does a deep copy of provided test setup
        /// </summary>
        /// <param name="copy">source record to copy</param>
        void Copy(ITestSetupRecord copy);
        /// <summary>
        /// Database Id of test setup
        /// </summary>
        int Id { get; set; }
        /// <summary>
        /// Name of test setup
        /// </summary>
        string Name { get; set; }
        /// <summary>
        /// Description of test setup
        /// </summary>
        string Description { get; set; }
        /// <summary>
        /// whether test execution should progress automatically
        /// </summary>
        bool AutomaticProgression { get; set; }
        /// <summary>
        /// delay between steps when using automatic progression
        /// </summary>
        int AutomaticProgressionDelayMS { get; set; }
        /// <summary>
        /// whether the trigger polarity should be switched from close to open
        /// </summary>
        bool InvertTriggerCompletion { get; set; }
        /// <summary>
        /// whether the start polarity should be switched from close to open
        /// </summary>
        bool InvertStartRecordCompletion { get; set; }
        /// <summary>
        /// Whether or not a shorted start should be ignored
        /// </summary>
        bool IgnoreShortedStartCompletion { get; set; }
        /// <summary>
        /// Whether or not a shorted trigger should be ignored
        /// </summary>
        bool IgnoreShortedTriggerCompletion { get; set; }
        /// <summary>
        /// Whether diagnostics should be a viewable step when executing test
        /// </summary>
        bool ViewDiagnostics { get; set; }
        /// <summary>
        /// whether verify channels should be a viewable step when executing test
        /// </summary>
        bool VerifyChannels { get; set; }

        bool AutoVerifyChannels { get; set; }
        double AutoVerifyDelaySeconds { get; set; }
        /// <summary>
        /// overall recording mode of test
        /// Some DAS may not support the actual recording mode but may support a related recording
        /// mode (example circular buffer + UART versus circular buffer)
        /// </summary>
        RecordingModes RecordingMode { get; set; }
        /// <summary>
        /// samples per second for test as overall value
        /// Each DAS can have it's own rate so this is mostly just to control the rate for new das added to a test
        /// </summary>
        double SamplesPerSecondAggregate { get; set; }
        /// <summary>
        /// amount of data pre trigger that is requested in seconds
        /// </summary>
        double PreTriggerSeconds { get; set; }
        /// <summary>
        /// amount of data post trigger that is requested in seconds
        /// </summary>
        double PostTriggerSeconds { get; set; }
        /// <summary>
        /// number of events to record if recording mode supports multiple events
        /// </summary>
        int NumberOfEvents { get; set; }
        /// <summary>
        /// whether all channels are required to pass diagnostics for test execution
        /// </summary>
        bool StrictDiagnostics { get; set; }
        /// <summary>
        /// whether user confirmation is required on diagnostic errors discovered before
        /// test execution continues
        /// </summary>
        bool RequireUserConfirmationOnErrors { get; set; }
        /// <summary>
        /// whether to perform a Region of Interest (ROI) download as a unique step of test execution
        /// </summary>
        bool DoROIDownload { get; set; }
        /// <summary>
        /// whether to include viewing region of interest (ROI) as a step of test execution
        /// </summary>
        bool ViewROIDownload { get; set; }
        /// <summary>
        /// whether to include downloading all available data as a step of test execution
        /// </summary>
        bool DownloadAll { get; set; }
        /// <summary>
        /// whether to include real time as a step of test execution
        /// </summary>
        bool ViewRealtime { get; set; }
        /// <summary>
        /// the number of plots to show in real time if viewing real time
        /// </summary>
        short DefaultNumberRealtimeGraphs { get; set; }
        BindingList<IRegionOfInterest> RegionsOfInterest { get; set; }
        /// <summary>
        /// the start of the region of interest (deprecated?)
        /// </summary>
        double ROIStart { get; set; }
        /// <summary>
        /// the end of the region of interest (deprecated?)
        /// </summary>
        double ROIEnd { get; set; }
        /// <summary>
        /// whether to include viewing of all download data as a step of test execution
        /// </summary>
        bool ViewDownloadAll { get; set; }
        /// <summary>
        /// whether to include export as a step of test execution
        /// </summary>
        bool ViewExport { get; set; }
        /// <summary>
        /// Bit mask of export formats to select in export step by default
        /// </summary>
        SupportedExportFormatBitFlags ExportFormats { get; set; }
        string LabDetails { get; set; }
        /// <summary>
        /// Whether lab details should be included as a part of test execution
        /// </summary>
        bool UseLabratoryDetails { get; set; }
        string CustomerDetails { get; set; }
        /// <summary>
        /// Whether customer details should be included as a part of test execution
        /// </summary>
        bool UseCustomerDetails { get; set; }
        /// <summary>
        /// Whether to allow test execution to continue when sensors in test are missing
        /// </summary>
        bool AllowMissingSensors { get; set; }
        /// <summary>
        /// whether a sensor with an ID is allowed to be assigned on a channel if the Id
        /// was not found on that channel
        /// </summary>
        bool AllowSensorIdToBlankChannel { get; set; }
        CalibrationBehaviors CalibrationBehavior { get; set; }
        /// <summary>
        /// whether test setup record should be synchronized with central server
        /// (deprecated)
        /// </summary>
        bool LocalOnly { get; set; }
        /// <summary>
        /// when test setup was last modified
        /// </summary>
        DateTime LastModified { get; set; }
        /// <summary>
        /// who last modified test setup
        /// </summary>
        string LastModifiedBy { get; set; }
        bool TurnOffExcitation { get; set; }
        /// <summary>
        /// whether to use EU levels to "trigger" channels in realtime viewer
        /// </summary>
        bool TriggerCheckRealtime { get; set; }
        /// <summary>
        /// Whether to include trigger check as a step in test execution
        /// </summary>
        bool TriggerCheckStep { get; set; }
        /// <summary>
        /// whether to include post test diagnostics as a step in test execution
        /// </summary>
        bool PostTestDiagnosticsLevel { get; set; }

        /// <summary>
        /// whether there's an expectation that there is a common status line between all DAS
        /// in test.
        /// </summary>
        bool CommonStatusLine { get; set; }
        bool SameAsDownloadFolder { get; set; }
        /// <summary>
        /// whether to include upload data as a step 
        /// </summary>
        bool UploadData { get; set; }
        /// <summary>
        /// folder to upload data to
        /// [legacy, superseded by upload ini file]
        /// </summary>
        string UploadFolder { get; set; }
        /// <summary>
        /// whether to upload only export data files when uploading files
        /// </summary>
        bool UploadExportsOnly { get; set; }
        string Settings { get; set; }
        bool WarnOnFailedBattery { get; set; }
        /// <summary>
        /// whether test setup completion has been calculated yet or not
        /// If dirty is true it has not been calculated and needs to be
        /// </summary>
        bool Dirty { get; set; }
        /// <summary>
        /// whether the test setup is complete and ready to run
        /// [dependent on Dirty]
        /// </summary>
        bool IsComplete { get; set; }
        /// <summary>
        /// any warnings or errors known in test setup, stored to avoid needing to calculate when retrieving all setups
        /// </summary>
        string ErrorMessage { get; set; }
        string TestEngineerDetails { get; set; }
        /// <summary>
        /// whether to use test engineer details in test execution
        /// </summary>
        bool UseTestEngineerDetails { get; set; }
        byte[] TagsBlobBytes { get; set; }
        /// <summary>
        /// whether units in the test should be auto armed
        /// </summary>
        bool DoAutoArm { get; set; }
        bool DoEnableRepeat { get; set; }
        /// <summary>
        /// Whether test is a checkout test
        /// this has multiple internal meanings including whether strict diagnostics are used or not, whether data
        /// should be collected from sensors or not, etc
        /// this should generally be false
        /// </summary>
        bool CheckoutMode { get; set; }
        /// <summary>
        /// Instrumentation Setup File used to create test setup, if relevant
        /// </summary>
        string ISFFile { get; set; }
        bool QuitTestWithoutWarning { get; set; }
        bool NotAllChannelsRealTime { get; set; }
        bool NotAllChannelsViewer { get; set; }
        bool SuppressMissingSensorsWarning { get; set; }
        bool DoStreaming { get; set; }
        ClockSyncProfile ClockSyncProfileMaster { get; set; }
        ClockSyncProfile ClockSyncProfileSlave { get; set; }
        List<IExtraProperty> ExtraProperties { get; set; }
        bool MeasureSquibResistancesStep { get; set; }
        string TestSetupUniqueId { get; set; }

        bool LowgLevelTriggerOn { get; set; }
        bool LowgLevelTriggerOnX { get; set; }
        bool LowgLevelTriggerOnY { get; set; }
        bool LowgLevelTriggerOnZ { get; set; }
        bool HighgLevelTriggerOn { get; set; }

        bool HighgLevelTriggerOnX { get; set; }
        bool HighgLevelTriggerOnY { get; set; }
        bool HighgLevelTriggerOnZ { get; set; }
        bool AngularAccelLevelTriggerOn { get; set; }
        bool AngularAccelLevelTriggerOnX { get; set; }
        bool AngularAccelLevelTriggerOnY { get; set; }
        bool AngularAccelLevelTriggerOnZ { get; set; }
        bool AngularRateLevelTriggerOn { get; set; }
        bool AngularRateLevelTriggerOnX { get; set; }
        bool AngularRateLevelTriggerOnY { get; set; }
        bool AngularRateLevelTriggerOnZ { get; set; }
        double LowgLinearLevelTriggerX { get; set; }
        double LowgLinearLevelTriggerY { get; set; }
        double LowgLinearLevelTriggerZ { get; set; }
        double HighgLinearLevelTriggerX { get; set; }
        double HighgLinearLevelTriggerY { get; set; }
        double HighgLinearLevelTriggerZ { get; set; }
        double AngularRateLevelTriggerX { get; set; }
        double AngularRateLevelTriggerY { get; set; }
        double AngularRateLevelTriggerZ { get; set; }
        double AngularAccelLevelTriggerX { get; set; }
        double AngularAccelLevelTriggerY { get; set; }
        double AngularAccelLevelTriggerZ { get; set; }
        bool HumidityLevelTriggerOn { get; set; }
        bool PressureLevelTriggerOn { get; set; }
        bool TemperatureLevelTriggerOn { get; set; }
        double HumidityLevelTriggerBelow { get; set; }
        double HumidityLevelTriggerAbove { get; set; }
        double PressureLevelTriggerBelow { get; set; }
        double PressureLevelTriggerAbove { get; set; }
        double TemperatureLevelTriggerBelow { get; set; }
        double TemperatureLevelTriggerAbove { get; set; }
        double LowgLinearAccRate { get; set; }
        double HighgLinearAccRate { get; set; }
        double AngularRate { get; set; }
        double TemperatureHumidityPressureRate { get; set; }
        bool BatterySaverModeOn { get; set; }
        bool WakeUpAndArmTriggerOn { get; set; }
        WakeupTriggers WakeUpTrigger { get; set; }
        int WakeUpMagnetTimeout { get; set; }
        int WakeUpMotionTimeout { get; set; }
        DateTime WakeUpTimeSessionStart { get; set; }
        TimeSpan WakeUpTimeDuration { get; set; }
        bool TimedIntervalTriggerOn { get; set; }
        int IntervalBetweenEventStartsMinutes { get; set; }
        TimeUnitTypeEnum TimedIntervalUnits { get; set; }
        double TimedIntervalDuration { get; set; }
        double TimedIntervalEvents { get; set; }
        bool RTCScheduleTriggerOn { get; set; }
        DateTime RTCScheduleStartDateTime { get; set; }
        TimeSpan RTCScheduleDuration { get; set; }
        bool StartWithEvent { get; set; }
        void InitializeFromDefaults(CalibrationBehaviors calBehavior,
            RecordingModes recordingMode, double preTriggerSeconds, double postTriggerSeconds,
            int numEvents);
        bool AlignUDPToPPS { get; set; }
    }
}