using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;


namespace DataStructures
{
    public enum MSG_HEADER
    {
        REG_REQUEST,
        REG_ACK,
        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,
        FILE_VERSION_GET,
        FILE_VERSION_ACK,
        DIR_VERSION_GET,
        DIR_VERSION_ACK,
        SYNC_START,
        SYNC_END

    }

    [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 RegistrationRequest
    {
        private string _username;
        private string _password;

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

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


    }

    [Serializable]
    public class RegistrationAck
    {
        private bool _regSucceeded;


        public bool regSucceeded { get { return _regSucceeded; } }


        public RegistrationAck(bool success)
        {
            _regSucceeded = success;
        }

    }

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

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

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

    }

    [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;
        public string fileSystemPath { get { return _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;
            try
            {
                computeChecksum();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        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())
                {
                    try
                    {
                        using (Stream fs = File.OpenRead(this._fileSystemPath))
                        {
                            _checksum = md5.ComputeHash(fs);
                        }
                    }
                    catch (IOException ex)
                    {
                        throw ex;
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }

                }
            }
            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>();
        }
    }

    [Serializable]
    public class PushFile
    {
        private FileStatus _fileStatus;
        public FileStatus fileStatus { get { return _fileStatus; } }

        public PushFile(FileStatus fileStatus)
        {
            _fileStatus = fileStatus;
        }
    }

    [Serializable]
    public class PushFileAck
    {
        private bool _success;
        public bool success
        {
            get { return _success; }
        }

        public PushFileAck(bool success)
        {
            _success = success;
        }
    }

    [Serializable]
    public class FileVersionGet
    {
        private FileStatus _fileVersion;
        public FileStatus fileVersion
        {
            get { return _fileVersion; }
        }

        public FileVersionGet(FileStatus fileVersion)
        {
            _fileVersion = fileVersion;
        }
    }

    [Serializable]
    public class FileVersionAck
    {
        private FileStatus _fileStatus;
        public FileStatus fileStatus
        {
            get { return _fileStatus; }
        }
        private Dictionary<int, DateTime> _fileVersions;
        public Dictionary<int, DateTime> fileVersions
        {
            get { return _fileVersions; }
        }

        public FileVersionAck(FileStatus fileStatus)
        {
            _fileStatus = fileStatus;
            _fileVersions = new Dictionary<int, DateTime>();
        }

        public void AddVersion(int versionId, DateTime versionDate)
        {
            _fileVersions.Add(versionId, versionDate);
        }
    }

    [Serializable]
    public class SyncStart
    {
        private int _files_to_sync;
        public int files_to_sync { get { return _files_to_sync; } }

        public SyncStart(int files_to_sync)
        {
            _files_to_sync = files_to_sync;
        }
    }

    [Serializable]
    public class SyncEnd
    {
        private bool _success;
        public bool success { get { return _success; } }

        public SyncEnd(bool success)
        {
            _success = success;
        }
    }

    [Serializable]
    public class RestoreFile
    {
        private int _version;
        private string _fullName;

        public int version { get { return _version; } }
        public string fullName { get { return _fullName; } }

        public RestoreFile(int version, string fullName)
        {
            _version = version;
            _fullName = fullName;
        }
    }

    [Serializable]
    public class RestoreFileAck
    {
        private int _size;
        public int size { get { return _size; } }

        public RestoreFileAck(int size)
        {
            _size = size;
        }
    }

    [Serializable]
    public class DirectoryVersionGet
    {
        private string _directoryName;
        public string directoryName
        {
            get { return _directoryName; }
        }

        public DirectoryVersionGet(string directoryName)
        {
            _directoryName = directoryName;
        }
    }

    [Serializable]
    public class DirectoryVersionAck
    {
        private string _directoryName;
        public string directoryName
        {
            get { return _directoryName; }
        }

        private Dictionary<int, List<RestoreFile>> _directoryVersions;
        public Dictionary<int, List<RestoreFile>> directoryVersions
        {
            get { return _directoryVersions; }
        }

        public DirectoryVersionAck(string directoryName, Dictionary<int, List<RestoreFile>> directoryVersions)
        {
            _directoryName = directoryName;
            _directoryVersions = directoryVersions;
        }

    }

    [Serializable]
    public class PullFile
    {
        private FileStatus _fileStatus;
        public FileStatus fileStatus { get { return _fileStatus; } }

        public PullFile(FileStatus fileStatus)
        {
            _fileStatus = fileStatus;
        }
    }

    [Serializable]
    public class PullFileAck
    {

        private int _size;
        public int size { get { return _size; } }

        public PullFileAck(int size)
        {
            _size = size;
        }
    }


}