using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DTS.Common.Classes.Sensors;
using DTS.Common.DAS.Concepts;
using DTS.Common.Enums;
using DTS.Common.Enums.Sensors;

namespace DTS.SensorDB.TDM
{
    /// <summary>
    /// this class handles logic of TDM CSV export it is partially built from 
    /// http://fogbugz/fogbugz/default.asp?5286#31544
    /// and http://build:8080/svn/Software/Code/TDASManager/trunk/source/sensor.c
    /// </summary>
    public class TDMCSVImport
    {
        /// <summary>
        /// most of these will get mapped to full bridge, a couple to half bridge
        /// the existing TDM code doesn't appear to consider 1/4 bridge
        /// </summary>
        private enum MeasurementTypes
        {
            MEASTYPE_FULLBRIDGE,
            MEASTYPE_HALFBRIDGE,
            MEASTYPE_VOLTAGE,
            MEASTYPE_IRTRACC,
            MEASTYPE_VOLTAGE_FB,
            MEASTYPE_POTENTIOMETER_FB,
            MEASTYPE_POTENTIOMETER_HB,
            MEASTYPE_ARS_ANGLE
        }

        /// <summary>
        /// Available filter types in the file
        /// note FIR100 not supported by SLICE code currently?
        /// </summary>
        private enum FilterTypes
        {
            FILTERTYPE_USEFREQ = 0,
            FILTERTYPE_CFC60,
            FILTERTYPE_CFC180,
            FILTERTYPE_CFC600,
            FILTERTYPE_CFC1000,
            FILTERTYPE_FIR100,
            FILTERTYPE_NONE,
            FILTERTYPE_UNFILTERED
        }
        /// <summary>
        /// possible zero methods for sensors
        /// </summary>
        private enum ZeroMethods
        {
            ZMETHOD_PREZERO = 1,
            ZMETHOD_AVGTIME,
            ZMETHOD_EQUALS0MV
        }
        /// <summary>
        /// goes from a label/string in CSV to an enum (measurement type)
        /// </summary>
        /// <param name="label"></param>
        /// <returns></returns>
        private static MeasurementTypes LabelToMeasurementType(string label)
        {
            switch (label)
            {
                case "Full Bridge": return MeasurementTypes.MEASTYPE_FULLBRIDGE;
                case "Half Bridge": return MeasurementTypes.MEASTYPE_HALFBRIDGE;
                case "Voltage Mode": return MeasurementTypes.MEASTYPE_VOLTAGE;
                case "IRTRACC": return MeasurementTypes.MEASTYPE_IRTRACC;
                case "Voltage Mode FB": return MeasurementTypes.MEASTYPE_VOLTAGE_FB;
                case "Potentiometer FB": return MeasurementTypes.MEASTYPE_POTENTIOMETER_FB;
                case "Potentiometer HB": return MeasurementTypes.MEASTYPE_POTENTIOMETER_HB;
                case "Angular Rate Sensor - Angle": return MeasurementTypes.MEASTYPE_ARS_ANGLE;
                default:
                    throw new NotSupportedException("unknown measurement type: " + label);
            }
        }
        /// <summary>
        /// goes from an enum to a label/string (measurement type)
        /// </summary>
        /// <param name="mt"></param>
        /// <returns></returns>
        private static string MeasurementTypeToLabel(MeasurementTypes mt)
        {
            switch (mt)
            {
                case MeasurementTypes.MEASTYPE_FULLBRIDGE: return "Full Bridge";
                case MeasurementTypes.MEASTYPE_HALFBRIDGE: return "Half Bridge";
                case MeasurementTypes.MEASTYPE_VOLTAGE: return "Voltage Mode";
                case MeasurementTypes.MEASTYPE_IRTRACC: return "IRTRACC";
                case MeasurementTypes.MEASTYPE_VOLTAGE_FB: return "Voltage Mode FB";
                case MeasurementTypes.MEASTYPE_POTENTIOMETER_FB: return "Potentiometer FB";
                case MeasurementTypes.MEASTYPE_POTENTIOMETER_HB: return "Potentiometer HB";
                case MeasurementTypes.MEASTYPE_ARS_ANGLE: return "Angular Rate Sensor - Angle";
                default:
                    throw new NotSupportedException("unknown measurement type: " + mt.ToString());
            }
        }

        /// <summary>
        /// all possible tags/columns in CSV
        /// </summary>
        public enum TAGS
        {
            SENSOR_CSV_LABEL_SERIAL_NO,
            SENSOR_CSV_LABEL_COMMENT,
            SENSOR_CSV_LABEL_EID,
            SENSOR_CSV_LABEL_CALDATE,
            SENSOR_CSV_LABEL_MANUFACTURER,
            SENSOR_CSV_LABEL_SENSOR_TYPE,
            SENSOR_CSV_LABEL_UNITS,
            SENSOR_CSV_LABEL_CAPACITY_EU,
            SENSOR_CSV_LABEL_MEASUREMENT_TYPE,
            SENSOR_CSV_LABEL_EXCITATION_VOLTS,
            SENSOR_CSV_LABEL_SENSITIVITY,
            SENSOR_CSV_LABEL_SENSITIVITY_UNITS,
            SENSOR_CSV_LABEL_INVERT,
            SENSOR_CSV_LABEL_USE_SHUNT_CAL,
            SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS,
            SENSOR_CSV_LABEL_ZMO_MV,
            SENSOR_CSV_LABEL_ZMO_UPDATE_MV,
            SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV,
            SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET,
            SENSOR_CSV_LABEL_TEST_DEVICE,
            SENSOR_CSV_LABEL_TEST_DEVICE_TYPE,
            SENSOR_CSV_LABEL_CODE,
            SENSOR_CSV_LABEL_JCODE,
            SENSOR_CSV_LABEL_FILTER_TYPE,
            SENSOR_CSV_LABEL_FILTER_FREQUENCY,
            SENSOR_CSV_LABEL_RANGE_0,
            SENSOR_CSV_LABEL_RANGE_1,
            SENSOR_CSV_LABEL_RANGE_2,
            SENSOR_CSV_LABEL_RANGE_3,
            SENSOR_CSV_LABEL_TOYOTA_CALC_1,
            SENSOR_CSV_LABEL_TOYOTA_CALC_2,
            SENSOR_CSV_LABEL_TOYOTA_CALC_3,
            SENSOR_CSV_LABEL_ZERO_METHOD,
            SENSOR_CSV_LABEL_ZERO_INITIAL_EU,
            SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC,
            SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC,
            SENSOR_CSV_LABEL_FLAGS,
            UNKNOWN //any flag we don't know gets stuffed into unkown
        }
        /// <summary>
        /// goes from a tag to a string/label (columns/fields)
        /// </summary>
        /// <param name="tag"></param>
        /// <returns></returns>
        private static string TagToLabel(TAGS tag)
        {
            switch (tag)
            {
                case TAGS.SENSOR_CSV_LABEL_SERIAL_NO: return "Serial No";
                case TAGS.SENSOR_CSV_LABEL_COMMENT: return "Comment";
                case TAGS.SENSOR_CSV_LABEL_EID: return "EID";
                case TAGS.SENSOR_CSV_LABEL_CALDATE: return "Calibration Date";
                case TAGS.SENSOR_CSV_LABEL_MANUFACTURER: return "Manufacturer";
                case TAGS.SENSOR_CSV_LABEL_SENSOR_TYPE: return "Sensor Type";
                case TAGS.SENSOR_CSV_LABEL_UNITS: return "Units";
                case TAGS.SENSOR_CSV_LABEL_CAPACITY_EU: return "Capacity (EU)";
                case TAGS.SENSOR_CSV_LABEL_MEASUREMENT_TYPE: return "Measurement Type";
                case TAGS.SENSOR_CSV_LABEL_EXCITATION_VOLTS: return "Excitation Volts";
                case TAGS.SENSOR_CSV_LABEL_SENSITIVITY: return "Sensitivity";
                case TAGS.SENSOR_CSV_LABEL_SENSITIVITY_UNITS: return "Sensitivity Units";
                case TAGS.SENSOR_CSV_LABEL_INVERT: return "Invert (1 = Yes, 0 = No)";
                case TAGS.SENSOR_CSV_LABEL_USE_SHUNT_CAL: return "Use Shunt Cal (1 = Yes, 0 = No)";
                case TAGS.SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS: return "Bridge Resistance Ohms";
                case TAGS.SENSOR_CSV_LABEL_ZMO_MV: return "ZMO mV";
                case TAGS.SENSOR_CSV_LABEL_ZMO_UPDATE_MV: return "ZMO Updated mV";
                case TAGS.SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV: return "ZMO Tolerance mV";
                case TAGS.SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET: return "Remove ZMO Offset";
                case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE: return "Test Device (DO NOT CHANGE)";
                case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE_TYPE: return "Test Device Type (DO NOT CHANGE)";
                case TAGS.SENSOR_CSV_LABEL_CODE: return "Ch. Code (DO NOT CHANGE)";
                case TAGS.SENSOR_CSV_LABEL_JCODE: return "J Code (DO NOT CHANGE)";
                case TAGS.SENSOR_CSV_LABEL_FILTER_TYPE: return "Filter Type";
                case TAGS.SENSOR_CSV_LABEL_FILTER_FREQUENCY: return "Filter Frequency";
                case TAGS.SENSOR_CSV_LABEL_RANGE_0: return "Low Range";
                case TAGS.SENSOR_CSV_LABEL_RANGE_1: return "Medium Range";
                case TAGS.SENSOR_CSV_LABEL_RANGE_2: return "High Range";
                case TAGS.SENSOR_CSV_LABEL_RANGE_3: return "Arbitrary Range";
                case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_1: return "Toyota Calc 1";
                case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_2: return "Toyota Calc 2";
                case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_3: return "Toyota Calc 3";
                case TAGS.SENSOR_CSV_LABEL_ZERO_METHOD: return "Zero Method";
                case TAGS.SENSOR_CSV_LABEL_ZERO_INITIAL_EU: return "Zero Initial EU";
                case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC: return "Zero Start Time ms";
                case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC: return "Zero End Time ms";
                case TAGS.SENSOR_CSV_LABEL_FLAGS: return "Flags";
            }
            throw new NotSupportedException("Unknown tag: " + tag.ToString());
        }
        /// <summary>
        /// goes from a label to a tag/string (columns/fields)
        /// </summary>
        /// <param name="label"></param>
        /// <returns></returns>
        public static TAGS LabelToTag(string label)
        {
            switch (label)
            {
                case "Serial No": return TAGS.SENSOR_CSV_LABEL_SERIAL_NO;
                case "Comment": return TAGS.SENSOR_CSV_LABEL_COMMENT;
                case "EID": return TAGS.SENSOR_CSV_LABEL_EID;
                case "Calibration Date": return TAGS.SENSOR_CSV_LABEL_CALDATE;
                case "Manufacturer": return TAGS.SENSOR_CSV_LABEL_MANUFACTURER;
                case "Sensor Type": return TAGS.SENSOR_CSV_LABEL_SENSOR_TYPE;
                case "Units": return TAGS.SENSOR_CSV_LABEL_UNITS;
                case "Capacity (EU)": return TAGS.SENSOR_CSV_LABEL_CAPACITY_EU;
                case "Measurement Type": return TAGS.SENSOR_CSV_LABEL_MEASUREMENT_TYPE;
                case "Excitation Volts": return TAGS.SENSOR_CSV_LABEL_EXCITATION_VOLTS;
                case "Sensitivity": return TAGS.SENSOR_CSV_LABEL_SENSITIVITY;
                case "Sensitivity Units": return TAGS.SENSOR_CSV_LABEL_SENSITIVITY_UNITS;
                case "Invert (1 = Yes, 0 = No)": return TAGS.SENSOR_CSV_LABEL_INVERT;
                case "Use Shunt Cal (1 = Yes, 0 = No)": return TAGS.SENSOR_CSV_LABEL_USE_SHUNT_CAL;
                case "Bridge Resistance Ohms": return TAGS.SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS;
                case "ZMO mV": return TAGS.SENSOR_CSV_LABEL_ZMO_MV;
                case "ZMO Updated mV": return TAGS.SENSOR_CSV_LABEL_ZMO_UPDATE_MV;
                case "ZMO Tolerance mV": return TAGS.SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV;
                case "Remove ZMO Offset": return TAGS.SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET;
                case "Test Device (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_TEST_DEVICE;
                case "Test Device Type (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_TEST_DEVICE_TYPE;
                case "Ch. Code (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_CODE;
                case "J Code (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_JCODE;
                case "Filter Type": return TAGS.SENSOR_CSV_LABEL_FILTER_TYPE;
                case "Filter Frequency": return TAGS.SENSOR_CSV_LABEL_FILTER_FREQUENCY;
                case "Low Range": return TAGS.SENSOR_CSV_LABEL_RANGE_0;
                case "Medium Range": return TAGS.SENSOR_CSV_LABEL_RANGE_1;
                case "High Range": return TAGS.SENSOR_CSV_LABEL_RANGE_2;
                case "Arbitrary Range": return TAGS.SENSOR_CSV_LABEL_RANGE_3;
                case "Toyota Calc 1": return TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_1;
                case "Toyota Calc 2": return TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_2;
                case "Toyota Calc 3": return TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_3;
                case "Zero Method": return TAGS.SENSOR_CSV_LABEL_ZERO_METHOD;
                case "Zero Initial EU": return TAGS.SENSOR_CSV_LABEL_ZERO_INITIAL_EU;
                case "Zero Start Time ms": return TAGS.SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC;
                case "Zero End Time ms": return TAGS.SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC;
                case "Flags": return TAGS.SENSOR_CSV_LABEL_FLAGS;
            }
            throw new NotSupportedException("unknown tag: " + label);
        }

        public static DTS.SensorDB.SensorData GetSensor(string[] tokens, TAGS[] tagOrder, ref List<string> errors, Dictionary<string, string> sensorTypeToDimension)
        {
            DTS.SensorDB.SensorData sd = new SensorData();
            sd.Calibration = new SensorCalibration();


            double filterFrequency = 0D;
            FilterTypes filterType = FilterTypes.FILTERTYPE_NONE;
            string calc1 = "";
            string calc2 = "";
            string calc3 = "";
            double dSensitivity = 0D;
            for (int i = 0; i < tokens.Length && i < tagOrder.Length; i++)
            {
                var tag = tagOrder[i];
                string sItem = tokens[i].Trim();
                //remove starting =" if found
                if (sItem.StartsWith("=")) { sItem = sItem.Substring(1); }
                //remove starting and trailing "
                if (sItem.StartsWith("\"") && sItem.EndsWith("\""))
                {
                    sItem = sItem.Substring(1, sItem.Length - 2);
                }
                try
                {
                    switch (tag)
                    {
                        case TAGS.SENSOR_CSV_LABEL_FLAGS:
                            //indicates marked for deletion ...
                            break;
                        case TAGS.SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS:
                            {
                                sItem = sItem.Trim();
                                double d;
                                if (double.TryParse(sItem, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.BridgeResistance = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_CALDATE:
                            {
                                sItem = sItem.Trim();
                                if (string.IsNullOrWhiteSpace(sItem))
                                {
                                    sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
                                }
                                else
                                {
                                    string[] subtokens = new string[0];

                                    string sDay = "";
                                    string sMonth = "";
                                    string sYear = "";

                                    if (sItem.Contains("/"))
                                    {
                                        sItem = sItem.Replace("//", "/");
                                        subtokens = sItem.Split('/');
                                        if (3 == subtokens.Length) { sYear = subtokens[2]; sMonth = subtokens[0]; sDay = subtokens[1]; }
                                    }
                                    else if (sItem.Contains("-"))
                                    {
                                        subtokens = sItem.Split('-');
                                        if (3 == subtokens.Length) { sYear = subtokens[0]; sMonth = subtokens[1]; sDay = subtokens[2]; }
                                    }


                                    if (3 != subtokens.Length)
                                    {
                                        errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                        sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
                                    }
                                    else
                                    {
                                        int d;
                                        int m;
                                        int y;
                                        if (int.TryParse(sMonth, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out m)
                                            && int.TryParse(sDay, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d)
                                            && int.TryParse(sYear, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out y))
                                        {
                                            try
                                            {
                                                sd.Calibration.CalibrationDate = new DateTime(y, m, d);
                                            }
                                            catch (System.Exception)
                                            {
                                                errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                                sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
                                            }
                                        }
                                        else
                                        {
                                            errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                            sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
                                        }
                                    }
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_CAPACITY_EU:
                            {
                                sItem = sItem.Trim();
                                double d;
                                if (double.TryParse(sItem, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.Capacity = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_CODE:
                            sd.UserValue2 = sItem;
                            break;
                        case TAGS.SENSOR_CSV_LABEL_COMMENT:
                            sd.Comment = sItem;
                            break;
                        case TAGS.SENSOR_CSV_LABEL_EID:
                            if (!string.IsNullOrWhiteSpace(sItem))
                            {
                                sd.EID = sItem;
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_EXCITATION_VOLTS:
                            {
                                double d;
                                if (!double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                }
                                else
                                {
                                    if (0 == d) { d = 5D; }//handle the "Voltage Insertion" mode, which is a 0 in the CSV for excitation
                                    var exc = DTS.Common.DAS.Concepts.Test.Module.Channel.Sensor.GetExcitationVoltageEnumFromMagnitude(d);
                                    sd.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { exc };
                                    sd.Calibration.Records.Records[0].Excitation = exc;
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_FILTER_FREQUENCY:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    filterFrequency = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_FILTER_TYPE:
                            {
                                int iType;
                                if (int.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out iType))
                                {
                                    filterType = (FilterTypes)iType;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_INVERT:
                            {
                                sItem = sItem.Trim();
                                switch (sItem.ToUpper())
                                {
                                    case "0":
                                    case "F":
                                    case "N": sd.Invert = false; break;
                                    case "1":
                                    case "Y":
                                    case "T": sd.Invert = true; break;
                                    default:
                                        errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                        break;
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_JCODE:
                            {
                                sd.UserValue1 = sItem;
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_MANUFACTURER:
                            {
                                sd.Manufacturer = sItem;
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_MEASUREMENT_TYPE:
                            {
                                var type = LabelToMeasurementType(sItem.Trim());
                                switch (type)
                                {
                                    case MeasurementTypes.MEASTYPE_ARS_ANGLE:
                                        sd.Bridge = SensorConstants.BridgeType.FullBridge;
                                        break;
                                    case MeasurementTypes.MEASTYPE_FULLBRIDGE:
                                        sd.Bridge = SensorConstants.BridgeType.FullBridge;
                                        break;
                                    case MeasurementTypes.MEASTYPE_HALFBRIDGE:
                                        sd.Bridge = SensorConstants.BridgeType.HalfBridge_SigPlus;
                                        break;
                                    case MeasurementTypes.MEASTYPE_IRTRACC:
                                        sd.Bridge = SensorConstants.BridgeType.FullBridge;
                                        sd.Calibration.NonLinear = true;
                                        sd.Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccDiagnosticsZero;
                                        sd.Calibration.Records.Records[0].Poly.MarkValid(true);
                                        break;
                                    case MeasurementTypes.MEASTYPE_POTENTIOMETER_FB:
                                        sd.Bridge = SensorConstants.BridgeType.FullBridge;
                                        break;
                                    case MeasurementTypes.MEASTYPE_POTENTIOMETER_HB:
                                        sd.Bridge = SensorConstants.BridgeType.HalfBridge_SigPlus;
                                        break;
                                    case MeasurementTypes.MEASTYPE_VOLTAGE:
                                        sd.Bridge = SensorConstants.BridgeType.HalfBridge_SigPlus;
                                        break;
                                    case MeasurementTypes.MEASTYPE_VOLTAGE_FB:
                                        sd.Bridge = SensorConstants.BridgeType.FullBridge;
                                        break;
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_RANGE_0:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.RangeLow = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_RANGE_1:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.RangeMedium = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_RANGE_2:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.RangeHigh = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_RANGE_3:
                            {
                                /*double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.Capacity = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }*/
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET:
                            {
                                switch (sItem.Trim().ToUpper())
                                {
                                    case "1":
                                    case "T":
                                    case "Y":
                                        sd.Calibration.RemoveOffset = true;
                                        break;
                                    case "0":
                                    case "F":
                                    case "N":
                                        sd.Calibration.RemoveOffset = false;
                                        break;
                                    default:
                                        errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                        break;
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_SENSITIVITY:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), out d))
                                {
                                    sd.Calibration.Records.Records[0].Sensitivity = d;
                                    dSensitivity = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_SENSITIVITY_UNITS:
                            {
                                switch (sItem.Trim().ToLower())
                                {
                                    case "mv/v/eu": sd.Calibration.IsProportional = true; sd.Calibration.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperVperEU; break;
                                    case "mv/eu": sd.Calibration.IsProportional = false; sd.Calibration.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperEU; break;
                                    default: errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); break;
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_SENSOR_TYPE:
                            {
                                if (!sensorTypeToDimension.ContainsKey(sItem.Trim()))
                                {
                                    errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                }
                                else
                                {
                                    sd.PhysicalDimension = sensorTypeToDimension[sItem.Trim()];
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_SERIAL_NO:
                            sd.SerialNumber = sItem.Trim();
                            sd.Calibration.SerialNumber = sd.SerialNumber;
                            break;
                        case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE:
                            //not currently used
                            break;
                        case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE_TYPE:
                            //not currently used
                            break;
                        case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_1:
                            calc1 = sItem.Trim();
                            break;
                        case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_2:
                            calc2 = sItem.Trim();
                            break;
                        case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_3:
                            calc3 = sItem.Trim();
                            break;
                        case TAGS.SENSOR_CSV_LABEL_UNITS:
                            sItem = sItem.Trim();
                            sd.DisplayUnit = sItem.Trim();
                            Array.ForEach(sd.Calibration.Records.Records, record => record.EngineeringUnits = sItem.Trim()); //FB16398: set units on all records, not just first                            
                            break;
                        case TAGS.SENSOR_CSV_LABEL_USE_SHUNT_CAL:
                            {
                                switch (sItem.Trim().ToUpper())
                                {
                                    case "0":
                                    case "F":
                                    case "N":
                                        sd.Shunt = ShuntMode.None;
                                        break;
                                    case "1":
                                    case "T":
                                    case "Y":
                                        sd.Shunt = ShuntMode.Emulation;
                                        break;
                                    default:
                                        errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
                                        break;

                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZERO_INITIAL_EU:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {//TODO: linear/nonlinear
                                    sd.Calibration.InitialOffsets = new InitialOffsets(new InitialOffset(d));
                                }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZERO_METHOD:
                            {
                                int iTemp;
                                if (int.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out iTemp))
                                {
                                    ZeroMethods zm = (ZeroMethods)iTemp;
                                    switch (zm)
                                    {
                                        case ZeroMethods.ZMETHOD_AVGTIME: sd.Calibration.ZeroMethods.Methods[0].Method = ZeroMethodType.AverageOverTime; break;
                                        case ZeroMethods.ZMETHOD_EQUALS0MV: sd.Calibration.ZeroMethods.Methods[0].Method = ZeroMethodType.None; break;
                                        case ZeroMethods.ZMETHOD_PREZERO: sd.Calibration.ZeroMethods.Methods[0].Method = ZeroMethodType.UsePreEventDiagnosticsZero; break;
                                        default: errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); break;
                                    }
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {//TODO: linear/nonlinear
                                    sd.Calibration.ZeroMethods.Methods[0].End = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {//TODO: linear/nonlinear
                                    sd.Calibration.ZeroMethods.Methods[0].Start = d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZMO_MV:
                            {
                                //we don't do anything with this currently
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV:
                            {
                                double d;
                                if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
                                {
                                    sd.OffsetToleranceHigh = d;
                                    sd.OffsetToleranceLow = -1D * d;
                                }
                                else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
                            }
                            break;
                        case TAGS.SENSOR_CSV_LABEL_ZMO_UPDATE_MV:
                            {
                                //we don't do anything with this currently
                            }
                            break;
                        case TAGS.UNKNOWN:
                            break;
                    }
                }
                catch (System.Exception ex)
                {
                    errors.Add("problem handing " + tag.ToString() + ": " + ex.Message);
                }
            }
            sd.UserValue3 = string.Format("{0}{1}{2}{1}{3}", calc1, System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, calc2, calc3);
            if (sd.Calibration.NonLinear)
            {
                sd.Calibration.Records.Records[0].Sensitivity = 0;
                sd.Calibration.Records.Records[0].Poly.LinearizationExponent = -75D / 175D;
                sd.Calibration.Records.Records[0].Poly.MMPerV = 1000D / dSensitivity;
            }
            switch (filterType)
            {
                case FilterTypes.FILTERTYPE_CFC1000: sd.Filter = new FilterClass(FilterClassType.CFC1000); break;
                case FilterTypes.FILTERTYPE_CFC180: sd.Filter = new FilterClass(FilterClassType.CFC180); break;
                case FilterTypes.FILTERTYPE_CFC60: sd.Filter = new FilterClass(FilterClassType.CFC60); break;
                case FilterTypes.FILTERTYPE_CFC600: sd.Filter = new FilterClass(FilterClassType.CFC600); break;
                case FilterTypes.FILTERTYPE_FIR100:
                    sd.Filter = new FilterClass(FilterClassType.CFC180);
                    errors.Add("FIR100 not supported - converting to CFC180");
                    break;
                case FilterTypes.FILTERTYPE_NONE: sd.Filter = new FilterClass(FilterClassType.None); break;
                case FilterTypes.FILTERTYPE_UNFILTERED: sd.Filter = new FilterClass(FilterClassType.Unfiltered); break;
                case FilterTypes.FILTERTYPE_USEFREQ: sd.Filter = new FilterClass(filterFrequency); break;
                default:
                    errors.Add("unknown filtertype: " + filterType.ToString());
                    break;
            }
            sd.UUID = sd.SerialNumber;
            if (sd.Capacity < 1)
            {
                sd.Capacity = 1;
                errors.Add(string.Format("{0} does not have a valid capacity.  A capacity of 1 will be used", sd.SerialNumber));
            }
            if (string.IsNullOrWhiteSpace(sd.DisplayUnit))
            {
                sd.DisplayUnit = "g";
                Array.ForEach(sd.Calibration.Records.Records, record => record.EngineeringUnits = "g"); //FB16398: set units on all records, not just first
                errors.Add(string.Format("{0} does not have engineering units specified.  A value of 'g' will be used", sd.SerialNumber));
            }
            return sd;
        }
    }
}