public class SkypeChatSyncer
    {
        private List<ChatSyncerRelation> chatSyncRelations { get; set; }

        public delegate void OnSendMessageRequiredDelegate(string message, string toSkypeId);
        public event OnSendMessageRequiredDelegate OnSendMessageRequired;

        public SkypeChatSyncer()
        {
            chatSyncRelations = new List<ChatSyncerRelation>();
            LoadRelations();
        }

        private void LoadRelations()
        {
            string configValue = ConfigurationManager.AppSettings["ChatSyncRelations"];
            if (!string.IsNullOrEmpty(configValue))
            {
                var relations = configValue.Split(';');
                foreach (string relation in relations)
                {
                    var relationParts = relation.Split('|');
                    if (relationParts.Length == 3)
                    {
                         
                        var fromChatIdParts = relationParts[0];
                        var toChatIdParts = relationParts[2];
                        
                        string relationOperator = relationParts[1];
                        if (relationOperator == "from")
                        {
                            string tempChatId = fromChatIdParts;
                            fromChatIdParts = toChatIdParts;
                            toChatIdParts = tempChatId;
                        }
                        chatSyncRelations.Add(new ChatSyncerRelation(fromChatIdParts, toChatIdParts));

                        if (relationOperator == "both")
                        {
                            //reverse
                            chatSyncRelations.Add(new ChatSyncerRelation(toChatIdParts,fromChatIdParts));
                        }
                    }
                }
            }
        }

        public void HandleMessage(string message, string fromName, string fromChatId)
        {
            var sendToChats = chatSyncRelations.Where(x => x.FromChatId == fromChatId).ToList();
            foreach (var chat in sendToChats)
            {
                string formattedMessage = string.Format("[{0}]{1} : {2}", chat.FromChatName, fromName, message);
                if (OnSendMessageRequired != null)
                {
                    OnSendMessageRequired(formattedMessage, chat.TochatId);
                }
            }
            
        }
    }

class Program
    {
        private static Skype skype = new Skype();
        private static HelloBot bot;
        private static SkypeChatSyncer chatSyncer;
        private static IDictionary<string,IChat> chats { get; set; }
        private static object _chatLocker = new object();

        static void Main(string[] args)
        {
            bot = new HelloBot();
            bot.OnErrorOccured += BotOnErrorOccured;
            Task.Run(delegate
            {
                try
                {
                    skype.MessageStatus += OnMessageReceived;
                    skype.Attach(5, true);
                    chatSyncer = new SkypeChatSyncer(); //init chat sync
                    chatSyncer.OnSendMessageRequired += ChatSyncerOnOnSendMessageRequired;
                    Console.WriteLine("skype attached");
                }
                catch (Exception ex)
                {
                    Console.WriteLine("top lvl exception : " + ex.ToString());
                }
                while (true)
                {
                    Thread.Sleep(1000);
                }
            });
            
            while (true)
            {
                Thread.Sleep(1000);
            }
        }

        private static void ChatSyncerOnOnSendMessageRequired(string message, string toSkypeId)
        {
            var chat = GetChatById(toSkypeId);
            if (chat != null)
            {
                SendMessage(message,chat);
            }
        }

        private static IChat GetChatById(string chatId)
        {
            if (chats == null)
            {
                lock (_chatLocker)
                {
                    if (chats == null)
                    {
                        chats = new Dictionary<string, IChat>();
                        foreach (IChat chat in skype.Chats)
                        {
                            string tChatId = chat.Name.Split(';').Last();
                            chats.Add(tChatId,chat);
                        }
                    }
                }
            }

            IChat toReturn = null;
            chats.TryGetValue(chatId, out toReturn);

            return toReturn;
        }

        static void BotOnErrorOccured(Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }

        private static void OnMessageReceived(ChatMessage pMessage, TChatMessageStatus status)
        {
            Console.WriteLine(status + pMessage.Body);
 
            if (status == TChatMessageStatus.cmsReceived)
            {
                bot.HandleMessage(pMessage.Body, answer => SendMessage(answer,pMessage.Chat),new SkypeData(pMessage));

                string fromChatId = pMessage.Chat.Name.Split(';').Last();
                chatSyncer.HandleMessage(pMessage.Body,pMessage.FromDisplayName,fromChatId);
            }
        }
        

        public static object _lock = new object();
        private static void SendMessage(string message, IChat toChat)
        {
            if (message.StartsWith("/"))
            {
                message = "(heidy) " + message;
            }
                lock (_lock)
                {
                    toChat.SendMessage(message);
                }
        }
    }