public enum PhoneState : byte
    {
        Unknown = 0,
        Ringing = 1,
        Calling = 2,
        Connected = 3,
        Disconnected = 4,
        MicUp = 5,
        MicDown = 6
    }

    class Device
    {
        /// <summary>
        /// Deklaracje zmiennych private
        /// </summary>
        private static Logger logger = LogManager.GetCurrentClassLogger();
       
        private string _phoneNo;

        private string _lastPhoneNo;

        private Blob _crossRefId;

        private bool _isMonitored = false;

        private long _lastInvokeId;

        private PhoneState _oldState = PhoneState.Unknown;

        private PhoneState _newState = PhoneState.Unknown;

        /// <summary>
        /// Deklaracje zmiennych public
        /// </summary>
        public bool isMonitored
        {
            get
            {
                return _isMonitored;
            }
            set
            {
                _isMonitored = value;
            }
        }

        public string phoneNo
        {
            get 
            { 
                return _phoneNo; 
            }
            set 
            { 
                _phoneNo = value; 
            }
        }

        public string lastPhoneNo
        {
            get
            {
                return _lastPhoneNo;
            }
            set
            {
                _lastPhoneNo = value;
            }
        }

        public Blob crossRefId
        {
            get
            {
                return _crossRefId;
            }
            set
            {
                _crossRefId = value;
            }
        }

        public long lastInvokeId
        {
            get
            {
                return _lastInvokeId;
            }
            set
            {
                _lastInvokeId = value;
            }
        }

        public PhoneState newState
        {
            get
            {
                return _newState;
            }
            set
            {
                _oldState = _newState;
                _newState = value;
            }
        }

        public PhoneState oldState
        {
            get
            {
                return _oldState;
            }
            set
            {
                _oldState = value;
            }
        }
        
        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="phoneNo">Numer telefonu odpowiadaj&#261;cy urz&#261;dzeniu którego monitorowania chcemy rozpocz&#261;&#263;</param>
        public Device(string phoneNo)
        {
            this.phoneNo = phoneNo;
            
            MonitorStartArgument msa = new MonitorStartArgument();
            
            msa.MonitorObject.Device.DialingNumber = this.phoneNo;

            CodeAndSend(msa, monitorStart_object.operationCode);
        }
        
        /// <summary>
        /// Pozwala wykona&#263; po&#322;&#261;czenie wychodz&#261;cego na dowolny numer telefonu
        /// </summary>
        /// <param name="phoneNo">Numer telefonu na który ma zosta&#263; wykonane po&#322;&#261;czenie</param>
        public void MakeCall(string phoneNo)
        {
            MakeCallArgument mca = new MakeCallArgument();
            
            mca.CallingDevice.DialingNumber = this.phoneNo;
            
            mca.CalledDirectoryNumber.DeviceIdentifier.DeviceIdentifier.DialingNumber = phoneNo;

            CodeAndSend(mca, makeCall_object.operationCode);
        }
        
        /// <summary>
        /// Odbieranie rozmowy - dzia&#322;a tylko w przypadku telefonów ISDN z funkcj&#261; telefonu g&#322;o&#347;nomówi&#261;cego
        /// </summary>
        public void AnswerCall()
        {
            AnswerCallArgument aca = new AnswerCallArgument();
            
            aca.CallToBeAnswered.Device.StaticID.DialingNumber = this.phoneNo;

            CodeAndSend(aca, answerCall_object.operationCode);
        }

        /// <param name="argument">Obiekt zawieraj&#261;cy dane które maj&#261; zosta&#263; wys&#322;ane do PBX/param>
        /// <param name="operationCode">Kod operacji</param>
        private void CodeAndSend(Unigone.Asn1RT.Type.Asn1Type argument, Unigone.Asn1RT.Type.Asn1Type operationCode)
        {
            Program.invokeId2phoneNo[Program.invokeId] = phoneNo;
            this.lastInvokeId = Program.invokeId;

            ROS rOS = new ROS();
            rOS.Invoke.InvokeId.Present = Program.invokeId++;
            rOS.Invoke.Opcode.SetValue(operationCode);
            rOS.Invoke.Argument = argument;

            try
            {
                rOS.Validate();
                Program.encoder.Encode(rOS);
            }
            catch (Asn1Exception ex)
            {
                logger.Error("ERROR WHILE CODING: " + argument.TypeName, ex);
                return;
            }
            
            PBXLink.Singleton.Write(Program.encoder.Data);
        }
    }



    class Program
    {
        private static Logger logger = LogManager.GetCurrentClassLogger();

        private static string monitored = "C:\\monitored.tmp";

        public static IEncoder encoder = CSTAp2Factory.CreateEncoder();

        public static IDecoder decoder = CSTAp2Factory.CreateDecoder();

        public static long invokeId;

        public static Dictionary<string, Device> Devices = new Dictionary<string, Device>();

        public static Dictionary<long, string> invokeId2phoneNo = new Dictionary<long, string>();
        
        public static Dictionary<Blob, string> crossRefId2phoneNo = new Dictionary<Blob, string>();

        static void Main(string[] args)
        {
            /// Otwieramy polaczenie z PBX i podpinamy odpowiedni&#261; metod&#281; która b&#281;dzie parsowa&#322;a
            /// dane w formacie ASN.1 przychod&#261;ce z PBX'a
            PBXLink.Singleton.Open("COM1");
            PBXLink.Singleton.OnMessage += new Message(PBXLink_OnMessage);

            /// Zatrzymujemy monitorowanie wszystkich urz&#261;dze&#324; których crossRedIf mamy zapisane
            /// w tymczasowym pliku na dysku - ma to zapobiega&#263; wielokrotnemu monitorowaniu tych samych urz&#261;dze&#324;,
            /// co skutkuje otrzymywaniem tego samego eventu wi&#281;cej ni&#380; jeden raz.
            StopMonitorOnAllDevices();
        }

        /// <summary>
        /// Metoda zatrzymuje monitorowanie wszystkich urz&#261;dze&#324; obecnie monitorowanych - s&#322;ownik Devices
        /// oraz urz&#261;dze&#324; monitorowanych w poprzedniej instancji aplikacji - plik tymczasowy na dysku
        /// </summary>
        private static void StopMonitorOnAllDevices()
        {

        }

        /// <summary>
        /// Parsuje dane ASN.1 na odpowiednie komunikaty CSTA i w zaleznosci od ich typu 
        /// uruchamia (zdarzenie) handleEvent lub (rezultat) handleResult
        /// </summary>
        /// <param name="data">Dane zgodne z formatem ASN.1 które maj&#261; zosta&#263; przeparsowane</param>
        private static void PBXLink_OnMessage(byte[] data)
        {
            byte[] pdu = data;

            ROS rOS = new ROS();

            try
            {
                decoder.Decode(pdu, rOS);
                rOS.Validate();
            }
            catch (Asn1Exception e)
            {
                logger.Error("Failed when parsing ASN.1", e);
                return;
            }

            logger.Info("ASN.1 data ok");

            if (rOS.IsInvoke() && rOS.Invoke.Argument is CSTAEventReportArgument)
            {
                handleEvent((CSTAEventReportArgument) rOS.Invoke.Argument);
            }
            else if (rOS.IsReturnResult() || rOS.IsReturnError() || rOS.IsReject())
            {
                handleReturn(rOS);
            }
        }

        private static void handleReturn(ROS rOS)
        {
            long invokeId;
            if (rOS.IsReturnResult())
                invokeId = rOS.ReturnResult.InvokeId.Present;
            else if (rOS.IsReturnError())
                invokeId = rOS.ReturnError.InvokeId.Present;
            else if (rOS.IsReject())
                invokeId = rOS.Reject.InvokeId.Present;

            if (rOS.IsReturnResult() && rOS.ReturnResult.HasResult())
            {
                if (rOS.ReturnResult.Result.Result is MonitorStartResult)
                {
                    /// <summary>
                    /// W obiekcie reprezentuj&#261;cym urz&#261;dzenie ustawiamy propercje crossRedId (wymagana przy odczytywaniu pewnych eventów)
                    /// oraz propercj&#281; isMonitored.
                    /// 
                    /// Do crossRefId2phoneNo dopisujemy numer telefonu, aby mozna pozniej szybko na podstawie crossRefId odszukac
                    /// odpowiedni obiekt w Devices.
                    /// 
                    /// Dopisujemy crossRefId do tymczasowego pliku na dysku twardym, program przy ka&#380;dym uruchomieniu usuwa monitory
                    /// z wszystkich urz&#261;dzen, których crossRefId znajduje si&#281; w tym pliku - zapobiega to wielokrotnemu
                    /// otrzymywaniu eventów informuj&#261;cych o tych samych zdarzeniach.
                    /// </summary>

                    logger.Info("MonitorStartResult");

                    MonitorStartResult msr = (MonitorStartResult)rOS.ReturnResult.Result.Result;
                    
                    if (invokeId2phoneNo.ContainsKey(rOS.ReturnResult.InvokeId.Present))
                    {
                        Devices[invokeId2phoneNo[rOS.ReturnResult.InvokeId.Present]].crossRefId = new Blob(msr.CrossRefIdentifier);
                        Devices[invokeId2phoneNo[rOS.ReturnResult.InvokeId.Present]].isMonitored = true;
                        crossRefId2phoneNo[new Blob(msr.CrossRefIdentifier)] = invokeId2phoneNo[rOS.ReturnResult.InvokeId.Present];
                    }

                    TextWriter tw = new StreamWriter(monitored, true);
                    tw.WriteLine(ByteArray.ByteArrayToHexString(msr.CrossRefIdentifier, "", 100));
                    tw.Close();
                }
                else if (rOS.ReturnResult.Result.Result is MakeCallResult)
                {
                    logger.Info("MakeCallResult");
                }
                else if (rOS.ReturnResult.Result.Result is SendDTMFTonesResult)
                {
                    logger.Info("SendDTMFTonesResult");
                }
                else if (rOS.ReturnResult.Result.Result is SetFeatureResult)
                {
                    logger.Info("SetFeatureResult");
                }
                else
                {
                    logger.Info("Other Result");
                }
            }
            else
            {
            }
        }

        private static void handleEvent(CSTAEventReportArgument era)
        {
            if (era.EventSpecificInfo.IsCallEvent())
            {
                logger.Info("-IsCallEvent");
                if (era.EventSpecificInfo.CallEvent.IsOriginatedEvent())
                {
                    TCPServer.Singleton.WriteToUser(era.EventSpecificInfo.CallEvent.OriginatedEvent.CallingDevice.DeviceIdentifier.DeviceIdentifier.DialingNumber, "IsOriginatedEvent:" + era.EventSpecificInfo.CallEvent.OriginatedEvent.CalledDevice.DeviceIdentifier.DeviceIdentifier.DialingNumber);

                    phoneNo2connId[era.EventSpecificInfo.CallEvent.OriginatedEvent.CallingDevice.DeviceIdentifier.DeviceIdentifier.DialingNumber] = new Blob(era.EventSpecificInfo.CallEvent.OriginatedEvent.OriginatedConnection.Call);
                    
                    connId2phoneNo[new Blob(era.EventSpecificInfo.CallEvent.OriginatedEvent.OriginatedConnection.Call)] = era.EventSpecificInfo.CallEvent.OriginatedEvent.CallingDevice.DeviceIdentifier.DeviceIdentifier.DialingNumber;


                    logger.Info("IsOriginatedEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsFailedEvent())
                {
                    logger.Info("IsFailedEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsDeliveredEvent())
                {
                    logger.Info("IsDeliveredEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsConnectionClearedEvent())
                {
                    logger.Info("IsConnectionClearedEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsEstablishedEvent())
                {
                    logger.Info("IsEstablishedEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsDivertedEvent())
                {
                    logger.Info("IsDivertedEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsHeldEvent())
                {
                    logger.Info("IsHeldEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsRetrievedEvent())
                {
                    logger.Info("IsRetrievedEvent");
                }
                else if (era.EventSpecificInfo.CallEvent.IsServiceInitiatedEvent())
                {
                    Devices[era.EventSpecificInfo.CallEvent.ServiceInitiatedEvent.InitiatedConnection.Device.StaticID.DialingNumber].newState = PhoneState.MicUp;
                    logger.Info("IsServiceInitiatedEvent");
                }
            }
        }
    }