using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using Common;
using SharedDatabase.Resources;

namespace SharedDatabase.Entities
{
    public class OrderInfo : IParamsProvider
    {
        public virtual int    Id { get; protected set; }
        public virtual string POName { get; set; }          /// 0
        public virtual sbyte  POState { get; set; }         /// 1   0=New, 1=Active, 2=Finished
        public virtual string Workflow { get; set; }        /// 2
        public virtual string TestProcedure { get; set; }   /// 3
        public virtual string VariantCode { get; set; }     /// 4
        public virtual int    PiecesCount { get; set; }     /// 5
        public virtual string SNPrefix { get; set; }        /// 6
        public virtual int    SNFirst { get; set; }         /// 7
        public virtual int    SNDigitsCount { get; set; }   /// 8
        public virtual string SNSuffix { get; set; }        /// 9
        public virtual string RAPrefix { get; set; }        /// 10
        public virtual int    RAFirst { get; set; }         /// 11
        public virtual int    RADigitsCount { get; set; }   /// 12
        public virtual string RASuffix { get; set; }        /// 13
        public virtual int    BaseNr1 { get; set; }
        public virtual int    BaseNr2 { get; set; }
        public virtual int    BaseNr3 { get; set; }
        public virtual int    BaseNr4 { get; set; }
        public virtual int    BaseNr5 { get; set; }
        public virtual string Remark { get; set; }          /// 14

        public OrderInfo()
        {
            POName = string.Empty;
            POState = (sbyte)OrderState.New;
            InitializeAll();
        }

        public OrderInfo(string orderName)
		{
            POName = orderName;
            POState = (sbyte)OrderState.New;
            InitializeAll();
        }

        public virtual void InitializeAll()
        {
            Workflow = string.Empty;
            TestProcedure = string.Empty;
            VariantCode = string.Empty;
            SNPrefix = string.Empty;
            SNSuffix = string.Empty;
            RAPrefix = string.Empty;
            RASuffix = string.Empty;
            Remark = string.Empty;
        }

        /// <summary>
        /// All members are copied except of ID (so that NHibernate works properly).
        /// List of groups is empty.
        /// </summary>
        /// <param name="newOrderNr">New order ID string</param>
        /// <param name="targetPiecesCount">-1 = the same number of pieces as the original order</param>
        /// <returns></returns>
        public virtual IParamsProvider Clone()
        {
            var newOrder = new OrderInfo();
            newOrder.POName = string.Empty;
            newOrder.POState = (sbyte)OrderState.New;
            newOrder.Workflow = Workflow;
            newOrder.TestProcedure = TestProcedure;
            newOrder.VariantCode = VariantCode;
            newOrder.PiecesCount = PiecesCount;
            newOrder.SNPrefix = SNPrefix;
            newOrder.SNFirst = SNFirst + PiecesCount;
            newOrder.SNDigitsCount = SNDigitsCount;
            newOrder.SNSuffix = SNSuffix;
            newOrder.RAPrefix = RAPrefix;
            newOrder.RAFirst = RAFirst + PiecesCount;
            newOrder.RADigitsCount = RADigitsCount;
            newOrder.RASuffix = RASuffix;
            newOrder.BaseNr1 = BaseNr1;
            newOrder.BaseNr2 = BaseNr2;
            newOrder.BaseNr3 = BaseNr3;
            newOrder.BaseNr4 = BaseNr4;
            newOrder.BaseNr5 = BaseNr5;
            newOrder.Remark = Remark;
            return newOrder;
        }

        public virtual XmlSerializer GetSerializer() { return null; }

        public virtual string ComponentName { get { return POName; } }

        string[] paramNames = new string[]
        {
            Strings.Order,
            Strings.State,
            Strings.Workflow,
            Strings.Test_procedure,
            Strings.Variant_code,
            Strings.Pieces_count,
            Strings.Serial_nr + " " + Strings.prefix,
            Strings.Serial_nr + " " + Strings.first,
            Strings.Serial_nr + " " + Strings.digits_count,
            Strings.Serial_nr + " " + Strings.suffix,
            Strings.Radio_address + " " + Strings.prefix,
            Strings.Radio_address + " " + Strings.first,
            Strings.Radio_address + " " + Strings.digits_count,
            Strings.Radio_address + " " + Strings.suffix,
            Strings.Remark,
        };
        public virtual string ParamName(int i) { return paramNames[i]; }
        public virtual int ParamsCount() { return paramNames.Length; }

        public virtual ICollection<string> ParamValues(int i)
        {
            var list = new List<string>();

            switch (i)
            {
                default:
                    return null;
            }
        }

        public virtual string ToString(int i)
        {
            switch (i)
            {
                case 0: return POName;
                case 1: return ((OrderState)POState).ToString();
                case 2: return Workflow;
                case 3: return TestProcedure;
                case 4: return VariantCode;
                case 5: return PiecesCount.ToString();
                case 6: return SNPrefix;
                case 7: return SNFirst.ToString();
                case 8: return SNDigitsCount.ToString();
                case 9: return SNSuffix;
                case 10: return RAPrefix;
                case 11: return RAFirst.ToString();
                case 12: return RADigitsCount.ToString();
                case 13: return RASuffix;
                case 14: return Remark;
                default:
                    return string.Format("order={0} pcs={1} wflow={2} proc={3} vaco={4} #1={5} #2={6} #3={7} #4={8} #5={9} remark={10}",
                                         POName, PiecesCount, Workflow, TestProcedure, VariantCode,
                                         BaseNr1, BaseNr2, BaseNr3, BaseNr4, BaseNr5, Remark);
            }
        }

        public virtual CfgUpdateFlags UpdateParam(int i, string str)
        {
            switch (i)
            {
                case 0:
                    POName = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 1:
                    POState = (sbyte)((str == OrderState.New.ToString()) ? OrderState.New :
                                      (str == OrderState.Active.ToString()) ? OrderState.Active : OrderState.Finished);
                    return CfgUpdateFlags.RestartRqrd;
                case 2:
                    Workflow = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 3:
                    TestProcedure = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 4:
                    VariantCode = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 5:
                    PiecesCount = int.Parse(str);
                    return CfgUpdateFlags.RestartRqrd;
                case 6:
                    SNPrefix = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 7:
                    SNFirst = int.Parse(str);
                    return CfgUpdateFlags.RestartRqrd;
                case 8:
                    SNDigitsCount = int.Parse(str);
                    return CfgUpdateFlags.RestartRqrd;
                case 9:
                    SNSuffix = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 10:
                    RAPrefix = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 11:
                    RAFirst = int.Parse(str);
                    return CfgUpdateFlags.RestartRqrd;
                case 12:
                    RADigitsCount = int.Parse(str);
                    return CfgUpdateFlags.RestartRqrd;
                case 13:
                    RASuffix = str;
                    return CfgUpdateFlags.RestartRqrd;
                case 14:
                    Remark = str;
                    return CfgUpdateFlags.RestartRqrd;
                default:
                    return CfgUpdateFlags.None;
            }
        }

        public virtual bool ValidateParam(int i, string str, out string message)
        {
            message = string.Empty;
            int idummy;

            switch (i)
            {
                case 0:
                case 2:
                case 3:
                case 4:
                    /// nonempty string
                    if (!string.IsNullOrEmpty(str)) return true;
                    message = string.Format(Strings._0_should_not_be_empty, ParamName(i));
                    return false;
                case 5:
                case 8:
                case 12:
                    /// positive integers
                    if (int.TryParse(str, out idummy) && idummy > 0) return true;
                    break;
                case 6:
                case 9:
                case 10:
                case 13:
                case 14:
                    /// strings
                    return true;
                case 7:
                case 11:
                    /// non-negative integer
                    if (int.TryParse(str, out idummy) && idummy >= 0) return true;
                    break;
                default:
                    message = "Invalid index";
                    return false;
            }

            message = string.Format(Strings.Invalid_0, ParamName(i));
            return false;
        }

        public virtual bool UpdateEmbeddedDbEntity()
        {
            return true;    /// =OK, do nothing
        }
    }

    public enum OrderState : sbyte
    {
        New = 0,
        Active = 1,
        Finished = 2,
    }
}