Mini Kabibi Habibi

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.SessionState;

public interface IMessage {
    int ID { get; set; }
    string Subject { get; set; }
    DateTime Date { get; set; }
    string From { get; set; }
    string To { get; set; }
    string Text { get; set; }
    string Folder { get; set; }
    bool HasAttachment { get; set; }
    bool IsReply { get; set; }
    bool Unread { get; set; }
}

public interface IContact {
    int ID { get; set; }
    string Name { get; set; }
    string Email { get; set; }
    string Address { get; set; }
    string Phone { get; set; }
    string Country { get; set; }
    string City { get; set; }
    string PhotoUrl { get; set; }
    bool Collected { get; set; }
}

public class Message : IMessage {
    DateTime _date;
    string _to;

    public int ID { get; set; }
    public string Subject { get; set; }
    public DateTime Date { get { return _date; } set { _date = value; } }
    public string From { get; set; }
    public string To { get { return _to; } set { _to = value; } }
    public string Text { get; set; }
    public string Folder { get; set; }
    public bool HasAttachment { get; set; }
    public bool IsReply { get; set; }
    public bool Unread { get; set; }
}

public class Contact : IContact {
    public int ID { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
    public string Phone { get; set; }
    public string Country { get; set; }
    public string City { get; set; }
    public string PhotoUrl { get; set; }
    public bool Collected { get; set; }
}

public static class DemoModel {
    static DataProviderBase currentProvider;
    public static DataProviderBase DataProvider {
        get {
            if(currentProvider == null)
                currentProvider = CreateDataProvider();
            return currentProvider;
        }
    }
    static DataProviderBase CreateDataProvider() {
        if(Utils.IsSiteMode)
            return new SiteModeDataProvider();
        return new DBDataProvider();
    }
}

public abstract class DataProviderBase {
    public abstract IEnumerable<IMessage> Messages { get; }
    public abstract IEnumerable<IMessage> UnreadMessages { get; }
    public abstract IEnumerable<IContact> Contacts { get; }

    public abstract void AddMessage(string subject, string to, string text, string folder);
    public abstract void UpdateMessage(int id, string subject, string to, string text, string folder);
    public abstract void MarkMessagesAs(bool read, IEnumerable<int> ids);
    public abstract void DeleteMessages(IEnumerable<int> ids);

    public abstract void AddContact(string name, string email, string address, string country, string city, string phone, string photoUrl);
    public abstract void UpdateContact(int id, string name, string email, string address, string country, string city, string phone, string photoUrl);
    public abstract void DeleteContact(int id);
}

public class DBDataProvider : DataProviderBase {
    public override IEnumerable<IMessage> Messages { get { return GetDataContext().DBMessages; } }
    public override IEnumerable<IMessage> UnreadMessages { get { return Messages.Where(m => m.Unread); } }
    public override IEnumerable<IContact> Contacts { get { return GetDataContext().DBContacts; } }

    protected WebmailClientDataContext GetDataContext() {
        return new WebmailClientDataContext();
    }

    public override void AddMessage(string subject, string to, string text, string folder) {
        var context = GetDataContext();
        context.DBMessages.InsertOnSubmit(new DBMessage() {
            Date = DateTime.Now,
            Subject = subject,
            From = Utils.ThomasEmail,
            To = to,
            Text = text,
            Folder = folder
        });
        context.SubmitChanges();
    }

    
    public override void UpdateMessage(int id, string subject, string to, string text, string folder) {
        var context = GetDataContext();
        var m = context.DBMessages.FirstOrDefault(i => i.ID == id);
        if(m == null)
            return;
        m.Date = DateTime.Now;
        m.Subject = subject;
        m.From = Utils.ThomasEmail;
        m.To = to;
        m.Text = text;
        m.Folder = folder;
        context.SubmitChanges();
    }
    public override void MarkMessagesAs(bool read, IEnumerable<int> ids) {
        var context = GetDataContext();
        foreach(var m in context.DBMessages.Where(i => ids.Contains(i.ID)))
            m.Unread = !read;
        context.SubmitChanges();
    }
    public override void DeleteMessages(IEnumerable<int> ids) {
        var context = GetDataContext();
        context.DBMessages.DeleteAllOnSubmit(context.DBMessages.Where(i => ids.Contains(i.ID)));
        context.SubmitChanges();
    }
    public override void AddContact(string name, string email, string address, string country, string city, string phone, string photoUrl) {
        var context = GetDataContext();
        context.DBContacts.InsertOnSubmit(new DBContact() {
            Name = name,
            Email = email,
            Address = address,
            Country = country,
            City = city,
            Phone = phone,
            PhotoUrl = photoUrl
        });
        context.SubmitChanges();
    }
    public override void UpdateContact(int id, string name, string email, string address, string country, string city, string phone, string photoUrl) {
        var context = GetDataContext();
        var c = context.DBContacts.FirstOrDefault(i => i.ID == id);
        if(c == null)
            return;
        c.Name = name;
        c.Email = email;
        c.Address = address;
        c.Country = country;
        c.City = city;
        c.Phone = phone;
        if(!string.IsNullOrEmpty(photoUrl))
            c.PhotoUrl = photoUrl;
        context.SubmitChanges();
    }
    public override void DeleteContact(int id) {
        var context = GetDataContext();
        var c = context.DBContacts.FirstOrDefault(i => i.ID == id);
        if(c == null)
            return;
        context.DBContacts.DeleteOnSubmit(c);
        context.SubmitChanges();
    }
}

public class SiteModeDataProvider : DataProviderBase {
    static List<Message> dbMessages;
    static List<Contact> dbContacts;

    protected static List<Message> DBMessages {
        get {
            if(dbMessages == null)
                dbMessages = CreateDBMessageList();
            return dbMessages;
        }
    }
    protected static List<Contact> DBContacts {
        get {
            if(dbContacts == null)
                dbContacts = CreateDBContactList();
            return dbContacts;
        }
    }

    static List<Message> CreateDBMessageList() {
        return new WebmailClientDataContext().DBMessages.Select(m => new Message() {
            ID = m.ID,
            Date = m.Date,
            Subject = m.Subject,
            From = m.From,
            To = m.To,
            Text = m.Text,
            Folder = m.Folder,
            Unread = m.Unread,
            HasAttachment = m.HasAttachment,
            IsReply = m.IsReply
        }).ToList();
    }

    static List<Contact> CreateDBContactList() {
        return new WebmailClientDataContext().DBContacts.Select(c => new Contact() {
            ID = c.ID,
            Name = c.Name,
            Email = c.Email,
            Address = c.Address,
            Country = c.Country,
            City = c.City,
            Phone = c.Phone,
            PhotoUrl = c.PhotoUrl,
            Collected = c.Collected
        }).ToList();
    }

    List<Message> messages;
    List<Contact> contacts;

    public SiteModeDataProvider() {
        Utils.StartClearExpiredFilesBackgroundThread();
    }

    HttpContext Context { get { return HttpContext.Current; } }
    HttpSessionState Session { get { return Context.Session; } }

    protected List<Message> SessionMessages {
        get {
            var key = "07A5E5BF-4C38-4C6C-A324-B81D24730AAD";
            if(Session[key] == null)
                Session[key] = new List<Message>();
            return (List<Message>)Session[key];
        }
    }

    protected List<int> DeletedDBMessagesKeys {
        get {
            var key = "4200605D-F2A3-4192-90CC-F11E739654FC";
            if(Session[key] == null)
                Session[key] = new List<int>();
            return (List<int>)Session[key];
        }
    }

    protected List<int> UnreadMessagesKeys {
        get {
            var key = "7B2D4B7E-5A7B-457B-B9D5-6821F55DE59E";
            if(Session[key] == null)
                Session[key] = DBMessages.Where(m => m.Unread).Select(i => i.ID).ToList();
            return (List<int>)Session[key];
        }
    }

    protected List<Contact> SessionContacts {
        get {
            var key = "068191AC-A820-483E-B450-8AD9DD1A51A7";
            if(Session[key] == null)
                Session[key] = new List<Contact>();
            return (List<Contact>)Session[key];
        }
    }

    protected List<int> DeletedDBContactsKeys {
        get {
            var key = "07B7041A-9416-4267-B9DB-BF53FAB64D3C";
            if(Session[key] == null)
                Session[key] = new List<int>();
            return (List<int>)Session[key];
        }
    }
    
    public override IEnumerable<IMessage> Messages {
        get {
            if(messages == null)
                messages = LoadMessages();
            return messages;
        }
    }

    public override IEnumerable<IMessage> UnreadMessages {
        get { return Messages.Where(m => UnreadMessagesKeys.Contains(m.ID)); }
    }

    public override IEnumerable<IContact> Contacts { 
        get {
            if(contacts == null)
                contacts = LoadContacts();
            return contacts;
        } 
    }

    protected List<Message> LoadMessages() {
        var list = new List<Message>();
        foreach(var dbMessage in DBMessages) {
            var sessionMessage = SessionMessages.FirstOrDefault(m => m.ID == dbMessage.ID);
            if(sessionMessage == null && !DeletedDBMessagesKeys.Contains(dbMessage.ID))
                list.Add(dbMessage);
        }
        list.AddRange(SessionMessages);
        return list;
    }

    protected List<Contact> LoadContacts() {
        var list = new List<Contact>();
        foreach(var dbContact in DBContacts) {
            var sessionContact = SessionContacts.FirstOrDefault(c => c.ID == dbContact.ID);
            if(sessionContact == null && !DeletedDBContactsKeys.Contains(dbContact.ID))
                list.Add(dbContact);
        }
        list.AddRange(SessionContacts);
        return list;
    }

    protected void ForceReloadMessages() {
        this.messages = null;
    }

    protected void ForceReloadContacts() {
        this.contacts = null;
    }

    public override void AddMessage(string subject, string to, string text, string folder) {
        SessionMessages.Add(new Message() {
            ID = Math.Max(DBMessages.Max(m => m.ID), Messages.Max(m => m.ID)) + 1,
            Date = DateTime.Now,
            Subject = subject,
            From = Utils.ThomasEmail,
            To = to,
            Text = text,
            Folder = folder
        });
        ForceReloadMessages();
    }

    public override void UpdateMessage(int id, string subject, string to, string text, string folder) {
        var m = SessionMessages.FirstOrDefault(i => i.ID == id);
        if(m == null) {
            m = DBMessages.FirstOrDefault(i => i.ID == id);
            if(m == null) return;
            SessionMessages.Add(m);
        }
        m.Date = DateTime.Now;
        m.Subject = subject;
        m.From = Utils.ThomasEmail;
        m.To = to;
        m.Text = text;
        m.Folder = folder;
        ForceReloadMessages();
    }

    public override void MarkMessagesAs(bool read, IEnumerable<int> ids) {
        foreach(var id in ids) {
            var contains = UnreadMessagesKeys.Contains(id);
            if(read && contains)
                UnreadMessagesKeys.Remove(id);
            else if(!read && !contains)
                UnreadMessagesKeys.Add(id);
        }
    }

    public override void DeleteMessages(IEnumerable<int> ids) {
        foreach(var id in ids) {
            var sessionMessage = SessionMessages.FirstOrDefault(m => m.ID == id);
            if(sessionMessage != null)
                SessionMessages.Remove(sessionMessage);
            else
                DeletedDBMessagesKeys.Add(id);
        }
        MarkMessagesAs(true, ids);
        ForceReloadMessages();
    }

    public override void AddContact(string name, string email, string address, string country, string city, string phone, string photoUrl) {
        SessionContacts.Add(new Contact() {
            ID = Math.Max(DBContacts.Max(c => c.ID), Contacts.Max(c => c.ID)) + 1,
            Name = name,
            Email = email,
            Address = address,
            Country = country,
            City = city,
            Phone = phone,
            PhotoUrl = photoUrl
        });
        ForceReloadContacts();
    }

    public override void UpdateContact(int id, string name, string email, string address, string country, string city, string phone, string photoUrl) {
        var c = SessionContacts.FirstOrDefault(i => i.ID == id);
        if(c == null) {
            c = DBContacts.FirstOrDefault(i => i.ID == id);
            if(c == null) return;
            SessionContacts.Add(c);
        }
        c.Name = name;
        c.Email = email;
        c.Address = address;
        c.Country = country;
        c.City = city;
        c.Phone = phone;
        if(!string.IsNullOrEmpty(photoUrl))
            c.PhotoUrl = photoUrl;
        ForceReloadContacts();
    }

    public override void DeleteContact(int id) {
        var sessionContact = SessionContacts.FirstOrDefault(c => c.ID == id);
        if(sessionContact != null)
            SessionContacts.Remove(sessionContact);
        DeletedDBContactsKeys.Add(id);
        ForceReloadContacts();
    }

}