using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace DataStructures
{
    public enum MSG_HEADER
    {
        LOGIN_REQUEST, //send usr and password
        LOGIN_ACK, //receive if login succeded or not
        FS_STATUS_GET, //send a list of FileStatus corresponding to all files in client fileSystem
        FS_STATUS_ACK, //receive a list of FileStatus corresponding to all files stored on server
        PUSH_FILE,
        PUSH_FILE_ACK,
        RESTORE_FILE,
        RESTORE_FILE_ACK
    }

    [Serializable]
    public class CatchallMessageModel
    {
        private MSG_HEADER _header;
        private object _content;

        public MSG_HEADER header { get { return _header; } }
        public object content { get { return _content; } }

        public CatchallMessageModel(MSG_HEADER header, object content)
        {
            _header = header;
            _content = content;
        }

        public static byte[] serialize(CatchallMessageModel message)
        {
            byte[] result;

            using (MemoryStream memStream = new MemoryStream())
            {
                BinaryFormatter serializer = new BinaryFormatter();
                serializer.Serialize(memStream, message);
                result = memStream.GetBuffer();
            }
            return result;
        }

        public static CatchallMessageModel deserialize(byte[] buffer)
        {

            using (MemoryStream memStream = new MemoryStream(buffer))
            {
                BinaryFormatter deserializer = new BinaryFormatter();
                object newobj = deserializer.Deserialize(memStream);
                return newobj as CatchallMessageModel;
            }
        }


    }

    [Serializable]
    public class LoginRequest
    {
        private string _username;
        private string _password;

        public string username { get { return _username; } }
        public string password { get { return _password; } }

        public LoginRequest(string u, string p)
        {
            _username = u;
            _password = p;
        }

    }

    [Serializable]
    public class LoginAck
    {
        private bool _loginSucceeded;


        public bool loginSucceeded { get { return _loginSucceeded; } }


        public LoginAck(bool success)
        {
            _loginSucceeded = success;
        }

    }

    [Serializable]
    public enum FILE_POSITION { ON_CLIENT, ON_SERVER, SYNCED }

    [Serializable]
    public class FileStatus
    {
        private string _fullName;
        public string fullName { get { return _fullName; } }

        private string _fileSystemPath;

        private byte[] _checksum;
        public byte[] checksum { get { return _checksum; } }

        private DateTime _lastModified;
        public DateTime lastModified { get { return _lastModified; } }

        private FILE_POSITION _position;
        public FILE_POSITION position
        {
            get { return _position; }
        }

        private bool _isFolder;
        public bool isFolder
        {
            get { return _isFolder; }
        }

        private int _fileSize;
        public int fileSize
        {
            get { return _fileSize; }
            set { _fileSize = value; }
        }

        public FileStatus(string fullName, string fileSystemPath , FILE_POSITION position, DateTime lastModified, bool isFolder = false)
        {
            _fullName = fullName;
            _fileSystemPath = fileSystemPath;
            _position = position;
            _isFolder = isFolder;
            _lastModified = lastModified;
            computeChecksum();
        }

        public FileStatus(string fullName, FILE_POSITION position, bool isFolder = false)
        {
            _fullName = fullName;
            _fileSystemPath = null;
            _position = position;
            _isFolder = isFolder;
            _lastModified = DateTime.MinValue;
            _checksum = null;
        }

        public void computeChecksum()
        {
            if (File.Exists(this._fileSystemPath))

            {
                using (MD5 md5 = MD5.Create())
                {
                    using (Stream fs = File.OpenRead(this._fileSystemPath))
                    {
                        _checksum = md5.ComputeHash(fs);
                    }
                }
            }
            else if (Directory.Exists(this._fileSystemPath))
            {
                _isFolder = true;
                _checksum = null;
            }
            else
            {
                throw new Exception("File doesn't exist.");
            }
        }

        public static bool operator ==(FileStatus f1, FileStatus f2)
        {
            if ((f1.fullName == f2.fullName) && (f1.checksum == f2.checksum))
                return true;

            if ((object)f1 == null && (object)f2 == null)
            {
                return true;
            }

            return false;

        }
        public static bool operator !=(FileStatus f1, FileStatus f2)
        {
            if (!(f1 == f2))
                return true;
            return false;
        }

        public override bool Equals(object obj)
        {
            return this == obj as FileStatus;
        }
    }

    [Serializable]
    public class FileSystemStatusGet
    {
        private string _root;
        public string root { get { return _root; } }

        private SortedList<string, FileStatus> _fileStatusList;
        public SortedList<string, FileStatus> fileStatusList { get { return _fileStatusList; } }

        public FileSystemStatusGet(string root)
        {
            _fileStatusList = new SortedList<string, FileStatus>();
            _root = root;
        }

    }

    [Serializable]
    public class FileSystemStatusAck
    {
        private SortedList<string, FileStatus> _fileStatusList;
        public SortedList<string, FileStatus> fileStatusList { get { return _fileStatusList; } }

        public FileSystemStatusAck()
        {
            _fileStatusList = new SortedList<string, FileStatus>();
        }
    }
}