messaging.cs

using System;

namespace MEL.Core.Messaging {
    //-- .NET using directives.
    using System.IO;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Threading;
    using System.Linq;
    using System.ServiceModel;

    //-- Internal using directives.
    using MEL.Core.IOTypes;


    public class Message {
        public Guid Sender = Guid.Empty;
        public Guid Receiver = Guid.Empty;
        public string Signature = "NULL";
        public string Subject = "NULL";
        public object Data = null;

        private int _lifetime = 3;
        public int Lifetime { get { return _lifetime; } }
        public void Update() { if (_lifetime > 0) _lifetime--; }

        public Message() {

        }

        public Message(Message _message) {
            Sender = _message.Receiver;
            Receiver = _message.Sender;
        }

        public Message(Message _message, string _signature) {
            Sender = _message.Receiver;
            Receiver = _message.Sender;
            Signature = _signature;
        }
    }

    public class BufferSystem {
        public List<Message> Messages { set; get; }
        public List<InputMessage> Input { set; get; }
        public List<OutputMessage> Output { set; get; }

        public BufferSystem() {
            Messages = new List<Message>();
            Input = new List<InputMessage>(); //for system I/O
            Output = new List<OutputMessage>();
        }
    }


    //-- Messaging

    public class MessageDispatcher {
        private static readonly object Locker = new object();

        public string MessagerName { private set; get; }
        public Guid Identifier { private set; get; }
        public BufferSystem Buffer { private set; get; }

        public MessageDispatcher() {
            MessagerName = "MESSAGING";
            Identifier = Guid.NewGuid();
            Buffer = new BufferSystem();
        }

        public void Update() {
            var _mr = new List<Message>();
            foreach (Message _m in Buffer.Messages) {
                _m.Update();
                if (_m.Lifetime <= 0) {
                    _mr.Add(_m);
                }
            }
            Buffer.Messages = Buffer.Messages.Except(_mr).ToList();
        }

        public void Send(Message _message) {
            lock (Locker) {
                Buffer.Messages.Add(_message);
            }
        }

        public List<Message> CheckMessages(Guid _identifier) {
            return CheckMessages(_identifier, true);
        }

        public List<Message> CheckMessages(Guid _identifier, bool _delete) {
            var _mr = new List<Message>();
            foreach (Message _m in Buffer.Messages) {
                if (_m.Receiver == _identifier) {
                    _mr.Add(_m);
                }
            }

            lock (Locker) {
                if (_delete)
                    Buffer.Messages = Buffer.Messages.Except(_mr).ToList();
            }

            return _mr;
        }
    }

    //-- Channels

    public class Channel {
        public string Name { private set; get; }
        public List<Guid> Recipients { private set; get; }

        public Channel(string _name) {
            Name = _name;
            Recipients = new List<Guid>();
        }

        public void Join(Guid _identifier) {
            Recipients.Add(_identifier);
        }

        public void Leave(Guid _identifier) {
            Recipients.Remove(_identifier);
        }
    }

    public class ChannelNetwork {
        public string MessagerName { private set; get; }
        public Guid Identifier { private set; get; }
        public List<Channel> Channels { private set; get; }

        public ChannelNetwork() {
            MessagerName = "CHANNEL_NETWORK";
            Identifier = Guid.NewGuid();
            Channels = new List<Channel>();
        }

        public void Update() {
            ScanMessages();
        }

        public void Send(string _channelname, Message _message) {
            Channel c = Channels.Find(x => x.Name == _channelname);
            if (c != null) {
                foreach (Guid g in c.Recipients) {
                    Message mes = _message;
                    mes.Receiver = g;
                    Globals.Messages.Send(mes);
                }
            }
        }

        private void ScanMessages() {
            var _messages = new List<Message>();
            _messages = Globals.Messages.CheckMessages(this.Identifier);

            foreach (Message _m in _messages) {
                Message mes = new Message(_m, MessagerName);
                List<string> ls = _m.Subject.Split(' ').ToList();

                if (ls.Count > 1) {
                    string command = ls[0];
                    string channelname = ls[1];
                    Channel c = Channels.Find(x => x.Name == channelname);

                    switch (command) {
                        case "JOIN":
                            if (c != null) {
                                c.Join(_m.Sender);
                                mes.Subject = "SUCCESS";
                            }
                        break;
                        case "LEAVE":
                            if (c != null) {
                                c.Leave(_m.Sender);
                                mes.Subject = "SUCCESS";
                            }
                        break;
                        case "CREATE":
                            if (c == null) {
                                Channels.Add(new Channel(channelname));
                                mes.Subject = "SUCCESS";
                            }
                        break;
                        case "DESTROY":
                            if (c != null) {
                                Channels.Remove(c);
                                mes.Subject = "SUCCESS";
                            }
                        break;
                        case "SEND":
                            Message protomes = _m.Data as Message;
                            if (c != null && protomes != null) {
                                this.Send(channelname, protomes);
                                mes.Subject = "SUCCESS";
                            }
                        break;
                    }
                }

                if (mes.Subject != "SUCCESS") {
                    mes.Subject = "FAILURE";
                }

                Globals.Messages.Send(mes);
            }
        }

        public Channel Find(string _name) {
            return Channels.Find(x => x.Name == _name);
        }
    }
}