using DependencyDemo.Classes.Database;
using DependencyDemo.Classes.Observers;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using DependencyDemo.Classes.Configuration;

namespace DependencyDemo.Classes.Controllers
{
    public class MainController
    {
        private List<Observer> observerList = new List<Observer>();

        private string Token { get; set; }
        private MFLogin mFLogin { get; set; }
        private DBLogin dBLogin { get; set; }
        private FolderwatcherConfig folderConfig { get; set; }

        private Vault SelectedVault { get; set; }
        public string VaultToken { get; private set; }

        private WatchController watchController;
        private FolderController folderController;

        public PropertyDef[] AllProperties { get; private set; }
        public ObjectClass[] AllClasses { get; private set; }
        public ObjType[] AllObjectTypes { get; private set; }

        private PropertyDef[] ArchivekeyProperties { get; set; }
        private PropertyDef[] RelationProperties { get;  set; }
        private PropertyDef[] ContpersProperties { get; set; }

        private System.Timers.Timer authTimer;

        public MainController()
        {
            InitLogin();
        }

        public void InitLogin()
        {
            mFLogin = new MFLogin();
            mFLogin.Server = "";
            mFLogin.Username = "";
            mFLogin.Password = "";
            mFLogin.Vault = "";

            dBLogin = new DBLogin();
            dBLogin.Server = "";
            dBLogin.Database = "";
            dBLogin.Username = "";
            dBLogin.Password = "";
        }

        public bool IsMFLoggedIn()
        {
            return mFLogin.LoggedIn;
        }

        public bool IsDBLoggedIn()
        {
            return dBLogin.LoggedIn;
        }

        public MFLogin GetMFLogin()
        {
            return mFLogin;
        }

        public DBLogin GetDBLogin()
        {
            return dBLogin;
        }

        public void SetLoginFromConfig()
        {
            try
            {
                if (File.Exists(@".\Config.xml"))
                {
                    XDocument doc = XDocument.Load(@".\Config.xml");
                    IEnumerable<XElement> elementMFiles = doc.Root.Elements("Login").Where(e => e.Attribute("program").Value.Equals("MFILES"));
                    IEnumerable<XElement> elementDbFact = doc.Root.Elements("Login").Where(e => e.Attribute("program").Value.Equals("SQL"));
                    IEnumerable<XElement> elementFolderWatcher = doc.Root.Elements("FolderWatcher");

                    if (elementDbFact.Count() != 0)
                    {
                        dBLogin.Server = elementDbFact.Select(e => e.Element("DBSERVER")).Single().Value;
                        dBLogin.Database = elementDbFact.Select(e => e.Element("DBDATABASE")).Single().Value;
                        dBLogin.Username = elementDbFact.Select(e => e.Element("DBUSERNAME")).Single().Value;
                        dBLogin.Password = new PasswordEncryptor().DecryptString(elementDbFact.Select(e => e.Element("DBPASSWORD")).Single().Value);
                    }
                    if (elementMFiles.Count() != 0)
                    {
                        mFLogin.Server = elementMFiles.Select(e => e.Element("MFSERVER")).Single().Value;
                        mFLogin.Username = elementMFiles.Select(e => e.Element("MFUSERNAME")).Single().Value;
                        mFLogin.Password = new PasswordEncryptor().DecryptString(elementMFiles.Select(e => e.Element("MFPASSWORD")).Single().Value);
                        mFLogin.Vault = elementMFiles.Select(e => e.Element("MFVAULT")).Single().Value;
                    }

                    if (elementFolderWatcher.Count() != 0)
                    {
                        folderConfig = new FolderwatcherConfig();
                        folderConfig.Watchfolder = elementFolderWatcher.Select(e => e.Element("WatchFolder")).SingleOrDefault().Value;
                        folderConfig.Dropfolder = elementFolderWatcher.Select(e => e.Element("DropFolder")).Single().Value;
                        int folderSeconds = -1;
                        int.TryParse(elementFolderWatcher.Select(e => e.Element("WatchSeconds")).Single().Value, out folderSeconds);
                        folderConfig.FolderSeconds = folderSeconds;
                    }

                    TestDBLogin();
                    GetTokens();
                    InitObjects();
                    ResetTimer();
                    if (folderController != null)
                    {
                        folderController.SetWatchFolderPath(folderConfig.Watchfolder);
                        folderController.SetDropFolderPath(folderConfig.Dropfolder);

                        if (folderController.IsWatching())
                            folderController.RestartFolderWatcher();
                    }
                }
            }
            catch (Exception ex)
            {
                if (ex is InvalidOperationException || ex is XmlException)
                {
                    NotifyObservers("", "Unable to read config file, check .\\Config.xml", "XML-error");
                }
            }
        }

        private void ResetTimer()
        {
            if (authTimer == null)
                authTimer = new System.Timers.Timer();

            if (authTimer.Enabled)
            {
                authTimer.Enabled = false;
                authTimer.Stop();
            }

            authTimer = new System.Timers.Timer();
            authTimer.Interval = 36000000;
            authTimer.Elapsed += AuthTimer_Tick;

            authTimer.Enabled = true;
        }

        private void AuthTimer_Tick(object sender, System.Timers.ElapsedEventArgs e)
        {
            SetLoginFromConfig();
        }

        public void SetMFLogin(string username, string password, string vault, string server)
        {
            mFLogin.Server = server;
            mFLogin.Vault = vault;
            mFLogin.Username = username;
            mFLogin.Password = password;
            GetTokens();
            InitObjects();
        }

        public void SetDBLogin(string server, string database, string username, string password)
        {
            dBLogin.Server = server;
            dBLogin.Database = database;
            dBLogin.Username = username;
            dBLogin.Password = password;
            TestDBLogin();
        }

        private void GetTokens()
        {
            try
            {
                Token = "";
                VaultToken = "";
                GetAuthToken();
                SelectNewVault();
                mFLogin.LoggedIn = true;
            }
            catch (WebException)
            {
                mFLogin.LoggedIn = false;
            }
        }

        public void TestDBLogin()
        {
            try
            {
                SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder()
                {
                    UserID = dBLogin.Username,
                    Password = dBLogin.Password,
                    DataSource = dBLogin.Server,
                    InitialCatalog = dBLogin.Database
                };
                using (SqlConnection connection = new SqlConnection(builder.ConnectionString))
                {
                    connection.Open();

                    if (connection.State == ConnectionState.Open)
                    {
                        dBLogin.LoggedIn = true;

                    }
                    else
                    {
                        dBLogin.LoggedIn = false;
                        NotifyObservers(dBLogin.Database, "Cannot login to database, check credentials and try again", "SQL error");
                    }
                }
            }
            catch (SqlException)
            {
                dBLogin.LoggedIn = false;
                NotifyObservers(dBLogin.Database, "Cannot login to database, check credentials and try again", "SQL error");
            }
        }

        public void RestartListening()
        {
            watchController.RestartListening();
        }

        public void StartListening()
        {
            Task connectToService = Task.Factory.StartNew(() =>
            {
                try
                {
                    if (watchController == null)
                        watchController = new WatchController(this, new DbQueries(dBLogin));
                    watchController.StartListening();
                    if (folderController == null)
                        folderController = new FolderController(this, new DbQueries(dBLogin));
                    folderController.SetDropFolderPath(folderConfig.Dropfolder);
                    folderController.SetWatchFolderPath(folderConfig.Watchfolder);
                    folderController.StartWatching();
                }
                catch (Exception)
                {
                    if (File.Exists(@".\Config.xml"))
                        NotifyObservers("", "Unable to check for changes -- try again later", "Unknown error");
                    else
                        NotifyObservers("", "No configuration found, please enter the settings first", "Settings");
                }
            });
        }

        public void StopListening()
        {
            watchController.StopListening();
        }

        public void RestartService()
        {
            Task restartTask = Task.Factory.StartNew(() =>
            {
                watchController.StopListening();
                watchController.RestartListening();
            });
        }

        #region M-FILES
        public void GetAuthToken()
        {
            try
            {
                Authentication auth = new Authentication() { Username = mFLogin.Username, Password = mFLogin.Password, WindowsUser = false };

                string url = String.Format("http://{0}/REST/server/authenticationtokens", mFLogin.Server);
                WebRequest request = WebRequest.Create(url);
                request.Method = "POST";

                var serializer = new DataContractJsonSerializer(typeof(Authentication));
                serializer.WriteObject(request.GetRequestStream(), auth);
                WebResponse response = request.GetResponse();

                var deserializer = new DataContractJsonSerializer(typeof(PrimitiveType<string>));
                PrimitiveType<string> token = (PrimitiveType<string>)deserializer.ReadObject(response.GetResponseStream());
                Token = token.Value;
            }
            catch (WebException)
            {
                NotifyObservers("", "-- Cannot login to M-Files, check login credentials and try again", "Webservice Error");
            }
        }

        private List<Vault> GetAvailableVaults()
        {
            List<Vault> vaults = new List<Vault>();
            try
            {
                string url = String.Format("http://{0}/REST/server/vaults", mFLogin.Server);
                WebRequest request = WebRequest.Create(url);
                request.Headers["X-Authentication"] = Token;

                // Get the response.
                WebResponse response = request.GetResponse();

                // Deserialize the view.
                var deserializer = new DataContractJsonSerializer(typeof(Vault[]));
                var result = (Vault[])deserializer.ReadObject(response.GetResponseStream());

                foreach (Vault vault in result)
                {
                    vaults.Add(vault);
                }

                return vaults;
            }
            catch (WebException)
            {
                throw;
            }
        }

        private void InitObjects()
        {
            AllObjectTypes = GetObjectTypes();
            AllProperties = GetAllProperties();
            AllClasses = GetAllClasses();
        }

        public void SelectNewVault()
        {
            if (!String.IsNullOrEmpty(Token))
            {
                try
                {
                    SelectedVault = GetAvailableVaults().Where(prop => prop.Name == mFLogin.Vault).FirstOrDefault();
                    VaultToken = SelectedVault.Authentication;
                }
                catch (Exception)
                {
                    NotifyObservers(mFLogin.Vault, "Cannot login to vault, check credentials and try again", "Cannot login to vault");
                }
            }

        }

        public WebResponse GetResponse(string url)
        {
            try
            {
                WebRequest request = WebRequest.Create(url);
                request.Headers["X-Authentication"] = VaultToken;
                WebResponse response = request.GetResponse();
                return response;
            }
            catch (WebException)
            {
                throw;
            }
        }

        public T GetResults<T>(string url)
        {
            try
            {
                var deserializer = new DataContractJsonSerializer(typeof(T));
                var response = GetResponse(url);
                if (response != null)
                {
                    var result = (T)deserializer.ReadObject(response.GetResponseStream());
                    return result;
                }
                else
                    return default(T);
            }
            catch (WebException)
            {
                NotifyObservers("", "Unable to communicate with the webservices, please try again later", "Webservice error");
                return default(T);
            }
        }

        public T GetPostResult<T>(WebResponse response)
        {
            var deserializer = new DataContractJsonSerializer(typeof(T));
            var createdObject = (T)deserializer.ReadObject(response.GetResponseStream());
            return createdObject;
        }

        public WebResponse PostObject<T>(string url, Object postObject)
        {
            try
            {
                var request = WebRequest.Create(url);
                request.Headers["X-Authentication"] = VaultToken;
                request.Method = "POST";
                var serializer = new DataContractJsonSerializer(typeof(T));
                serializer.WriteObject(request.GetRequestStream(), postObject);
                return request.GetResponse();
            }
            catch (WebException)
            {
                throw;
            }

        }

        public int GetObjectClassID(string objectClass)
        {
            int objectID = -1;
            objectID = AllClasses.Where(n => n.Name == objectClass).Select(n => n.ID).FirstOrDefault();
            return objectID;
        }

        public int GetDocumentTypeID(string documentType)
        {
            int docTypeID = -1;
            int docTypeObjectID = GetObjectTypeID("Document Type");
            int shortnamePropertyId = AllProperties.Where(propName => propName.Name == "Doctype Shortname").Select(val => val.ID).FirstOrDefault();

            string url = String.Format("http://{0}/REST/objects/{1}?p{2}={3}", mFLogin.Server, docTypeObjectID, shortnamePropertyId, documentType);
            var result = GetResults<Results<ObjectVersion>>(url);
            docTypeID = result.Items.FirstOrDefault().ObjVer.ID;

            return docTypeID;
        }

        private ObjType[] GetObjectTypes()
        {
            string url = String.Format("http://{0}/REST/structure/objecttypes", mFLogin.Server);
            var result = GetResults<ObjType[]>(url);

            return result;
        }

        public int GetObjectTypeID(string objectType)
        {
            int objectID = -1;

            if (AllObjectTypes != null)
            {
                objectID = AllObjectTypes.Where(n => n.Name == objectType).Select(n => n.ID).FirstOrDefault();
                return objectID;
            }
            else
                return 0;
        }

        private PropertyDef[] GetAllProperties()
        {
            string url = String.Format("http://{0}/REST/structure/properties", mFLogin.Server);
            var result = GetResults<PropertyDef[]>(url);
            return result;
        }

        private ObjectClass[] GetAllClasses()
        {

            string url = String.Format("http://{0}/REST/structure/classes", mFLogin.Server);
            return GetResults<ObjectClass[]>(url);

        }

        public void CheckOutItem(int type, ObjectVersion ov)
        {
            try
            {
                var url = string.Format("http://{0}/REST/objects/{1}/{2}/checkedout?_method=PUT", mFLogin.Server, type, ov.ObjVer.ID);
                var status = new PrimitiveType<MFCheckOutStatus> { Value = MFCheckOutStatus.CheckedOutToMe };
                var response = PostObject<PrimitiveType<MFCheckOutStatus>>(url, status);
            }
            catch(WebException)
            {
                NotifyObservers(ov.Title, "Unable to checkout document, check if document is checked out by someone else", "Webservice error");
            }

        }

        public ObjectVersion CheckInItem(int type, ObjectVersion ov)
        {
            try
            {
                var url = string.Format("http://{0}/REST/objects/{1}/{2}/checkedout?_method=PUT", mFLogin.Server, type, ov.ObjVer.ID);
                var status = new PrimitiveType<MFCheckOutStatus> { Value = MFCheckOutStatus.CheckedIn };
                var response = PostObject<PrimitiveType<MFCheckOutStatus>>(url, status);
                if (response != null)
                    return GetPostResult<ObjectVersion>(response);
                else
                    return CheckInItem(type, ov);
            }
            catch (WebException)
            {
                NotifyObservers(ov.Title, "Unable to checkout document, check if document is checked out by someone else", "Webservice error");
                return default(ObjectVersion);
            }

        }

        private PropertyDef[] GetClassProperties(ExtendedObjectClass classObject)
        {
            List<PropertyDef> properties = new List<PropertyDef>();

            foreach (AssociatedPropertyDef associatedProperty in classObject.AssociatedPropertyDefs)
            {
                PropertyDef property = AllProperties.Where(prop => prop.ID == associatedProperty.PropertyDef).Select(val => val).FirstOrDefault();
                properties.Add(property);
            }

            return properties.ToArray();
        }

        private void GetArchivekeyProperties()
        {
            int archivekeyObjectID = GetObjectClassID("Archiefkey");
            string url = String.Format("http://{0}/REST/structure/classes/{1}", mFLogin.Server, archivekeyObjectID);
            ExtendedObjectClass archivekeyClass = GetResults<ExtendedObjectClass>(url);

            ArchivekeyProperties = GetClassProperties(archivekeyClass);
        }

        public int GetArchiveKeyPropertyID(string propertyName)
        {
            if (ArchivekeyProperties == null)
                GetArchivekeyProperties();
            return ArchivekeyProperties.Where(n => n.Name == propertyName).Select(n => n.ID).FirstOrDefault();
        }

        private void GetRelationProperties()
        {
            int relationObjectID = GetObjectClassID("Relatie");
            string url = String.Format("http://{0}/REST/structure/classes/{1}", mFLogin.Server, relationObjectID);
            ExtendedObjectClass relationClass = GetResults<ExtendedObjectClass>(url);

            RelationProperties = GetClassProperties(relationClass);
        }

        public int GetRelationPropertyID(string propertyName)
        {
            if (RelationProperties == null)
                GetRelationProperties();
            return RelationProperties.Where(n => n.Name == propertyName).Select(n => n.ID).FirstOrDefault();
        }

        private void GetContpersProperties()
        {
            int contpersObjectID = GetObjectClassID("Contactpersoon");
            string url = String.Format("http://{0}/REST/structure/classes/{1}", mFLogin.Server, contpersObjectID);
            ExtendedObjectClass contpersClass = GetResults<ExtendedObjectClass>(url);

            ContpersProperties = GetClassProperties(contpersClass);
        }

        public int GetContpersPropertyID(string propertyName)
        {
            if (ContpersProperties == null)
                GetContpersProperties();
            return ContpersProperties.Where(n => n.Name == propertyName).Select(n => n.ID).FirstOrDefault();
        }

        public int GetPropertyId(string objectType)
        {
            switch (objectType)
            {
                case "Archiefkey":
                    return GetArchiveKeyPropertyID("Archief Barcode");
                case "Relatie":
                    return GetRelationPropertyID("Relatie ID");
                case "Contactpersoon":
                    return GetContpersPropertyID("Contact ID");
                default:
                    return -1;
            }
        }

        public int GetRelnumID(int relnum)
        {
            try
            {
                int relnumID = 0;
                int relObjectID = GetObjectTypeID("Relatie");
                int relPropertyID = GetPropertyId("Relatie");

                string url = String.Format("http://{0}/REST/objects/{1}?p{2}={3}", mFLogin.Server, relObjectID, relPropertyID, relnum);
                var result = GetResults<Results<ObjectVersion>>(url);
                relnumID = result.Items.FirstOrDefault().ObjVer.ID;

                return relnumID;
            }
            catch (NullReferenceException)
            {
                return 0;
            }
        }

        public ObjectVersion GetObjectWithProperty(string objectType, int propertyId, string identifier)
        {
            //int objectTypeID = GetObjectTypeID(objectType);
            string url = String.Format("http://{0}/REST/objects/{1}?p{2}={3}", mFLogin.Server, objectType, propertyId, identifier);
            var result = GetResults<Results<ObjectVersion>>(url);

            if (result == null)
                return default(ObjectVersion);

            ObjectVersion objectV = result.Items.FirstOrDefault();

            return objectV;
        }

        public PropertyValue[] GetPropertiesOfObject(ObjectVersion objectV, string objectType)
        {
            int objectTypeID = GetObjectTypeID(objectType);
            string url = String.Format("http://{0}/REST/objects/{1}/{2}/properties", mFLogin.Server, objectTypeID, objectV.ObjVer.ID);
            var result = GetResults<PropertyValue[]>(url); ;

            return result;
        }

        public void PostNewArchiveKey(Archive archive)
        {
            int archiveObjectID = GetObjectTypeID("Archiefkey");
            ObjectCreationInfo creationInfo = CreateNewArchiveKey(archive);
            string url = String.Format("http://{0}/REST/objects/{1}", mFLogin.Server, archiveObjectID);
            PostNewObject(url, creationInfo);
        }

        public void PostNewRelation(Relation relation)
        {
            int relationObjectID = GetObjectTypeID("Relatie");
            ObjectCreationInfo creationInfo = CreateNewRelation(relation);
            string url = String.Format("http://{0}/REST/objects/{1}", mFLogin.Server, relationObjectID);
            PostNewObject(url, creationInfo);
        }

        public void PostNewContpers(Contpers contpers)
        {
            int ContpersObjectID = GetObjectTypeID("Contactpersoon");
            ObjectCreationInfo creationInfo = CreateNewContpers(contpers);
            string url = String.Format("http://{0}/REST/objects/{1}", mFLogin.Server, ContpersObjectID);
            PostNewObject(url, creationInfo);
        }

        public ObjectVersion DeleteObject(ObjectVersion deletedObject, string objectTypeId)
        {
            try
            {
                int objectId = -1;
                int.TryParse(objectTypeId, out objectId);
                CheckOutItem(objectId, deletedObject);
                string url = String.Format("http://{0}/REST/objects/{1}/{2}/?allVersions&_method=DELETE", mFLogin.Server, objectTypeId, deletedObject.ObjVer.ID);
                var response = PostObject<ObjectVersion>(url, deletedObject);
                if (response != null)
                {
                    var createdObject = GetPostResult<ObjectVersion>(response);
                    if (createdObject.Class == GetObjectClassID("Archiefkey"))
                        NotifyObservers("Archiefkey", createdObject.Title, "DELETE", "MFILES");
                    else if (createdObject.Class == GetObjectClassID("Relatie"))
                        NotifyObservers("Relatie", createdObject.Title, "DELETE", "MFILES");
                    else if (createdObject.Class == GetObjectClassID("Contactpersoon"))
                        NotifyObservers("Contactpersoon", createdObject.Title, "DELETE", "MFILES");
                    return createdObject;
                }
                return default(ObjectVersion);
            }
            catch (WebException)
            {
                NotifyObservers(deletedObject.Title, "Unable to delete item, please try again later", "Webservice error");
                return default(ObjectVersion);
            }
        }

        public ObjectVersion PostNewObject(string url, ObjectCreationInfo creationInfo)
        {
            var response = PostObject<ObjectCreationInfo>(url, creationInfo);
            if (response != null)
            {
                var createdObject = GetPostResult<ObjectVersion>(response);
                if (createdObject.Class == GetObjectClassID("Archiefkey"))
                    NotifyObservers("Archiefkey", createdObject.Title, "INSERT", "MFILES");
                else if (createdObject.Class == GetObjectClassID("Relatie"))
                    NotifyObservers("Relatie", createdObject.Title, "INSERT", "MFILES");
                else if (createdObject.Class == GetObjectClassID("Contactpersoon"))
                    NotifyObservers("Contactpersoon", createdObject.Title, "INSERT", "MFILES");
                return createdObject;
            }
            else
                return PostNewObject(url, creationInfo);

        }

        public ObjectCreationInfo CreateNewArchiveKey(Archive archive)
        {
            int docTypeID = GetDocumentTypeID(archive.DocType);
            int relnumID = GetRelnumID(archive.RelNum);

            ObjectCreationInfo creationInfo = new ObjectCreationInfo
            {
                PropertyValues = new[]
                {
                    new PropertyValue
                    {
                        PropertyDef = 100,
                        TypedValue = new TypedValue { DataType = MFDataType.Lookup,  Lookup = new Lookup { Item = GetObjectClassID("Archiefkey"), Version=-1 } }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Archief Barcode"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = archive.ArchKey }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Document Journaal"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = archive.DocJrnl }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Document Nummer"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = archive.DocNum }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Document Datum"),
                        TypedValue = new TypedValue { DataType = MFDataType.Date, Value = archive.Docdat.AddDays(1) }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Document Opmerking"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = archive.DocOpm }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Relatie"),
                        TypedValue = new TypedValue { DataType = MFDataType.MultiSelectLookup, Lookups = new Lookup[] {
                            new Lookup {
                                Item = relnumID, Version = -1
                            } }
                        }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetArchiveKeyPropertyID("Relnaam (info)"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = archive.RelNaam }
                    },
                    new PropertyValue
                    {
                        PropertyDef = GetArchiveKeyPropertyID("Boekjaar"),
                        TypedValue = new TypedValue { DataType = MFDataType.Integer, Value = archive.BoekJaar }
                    }
                }
            };

            if (docTypeID != -1)
            {
                List<PropertyValue> propertyList = creationInfo.PropertyValues.ToList();
                propertyList.Add(new PropertyValue
                {
                    PropertyDef = GetArchiveKeyPropertyID("Document Type"),
                    TypedValue = new TypedValue
                    {
                        DataType = MFDataType.MultiSelectLookup,
                        Lookups = new Lookup[] {
                            new Lookup {
                                Item = docTypeID, Version = -1
                            }
                        }
                    }
                });
                creationInfo.PropertyValues = propertyList.ToArray();
            }

            if (relnumID == 0 || docTypeID == 0)
            {
                List<PropertyValue> propertyList = creationInfo.PropertyValues.ToList();
                if (relnumID == 0)
                    propertyList.RemoveAll(v => v.PropertyDef == GetArchiveKeyPropertyID("Relatie"));
                if (docTypeID == 0)
                    propertyList.RemoveAll(v => v.PropertyDef == GetArchiveKeyPropertyID("Document Type"));
                creationInfo.PropertyValues = propertyList.ToArray();
            }

            return creationInfo;
        }

        public ObjectCreationInfo CreateNewRelation(Relation relation)
        {

            ObjectCreationInfo creationInfo = new ObjectCreationInfo
            {
                PropertyValues = new[]
                {
                    new PropertyValue
                    {
                        PropertyDef = 100,
                        TypedValue = new TypedValue { DataType = MFDataType.Lookup,  Lookup = new Lookup { Item = GetObjectClassID("Relatie"), Version=-1 } }
                    },
                    new PropertyValue
                    {
                        PropertyDef = GetRelationPropertyID("Relatie Naam"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = relation.Name }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Straat"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = relation.Address}
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Postcode"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.ZipCode }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Plaats"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.Place }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Landcode"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.Isoland }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Relatiecode"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.Relcode }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Relatiestatus"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.RelStatus}
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Relatie Email"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.Email }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID("Relatie ID"),
                        TypedValue = new TypedValue {DataType = MFDataType.Integer, Value = relation.Relnum }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetRelationPropertyID( "Relatie Alternatief nummer"),
                        TypedValue = new TypedValue { DataType = MFDataType.Text, Value = relation.BNum }
                    }
                }
            };

            return creationInfo;
        }

        public ObjectCreationInfo CreateNewContpers(Contpers contpers)
        {
            int relNum = GetRelnumID(contpers.RelNum);

            ObjectCreationInfo creationInfo = new ObjectCreationInfo
            {
                PropertyValues = new[]
                {
                    new PropertyValue
                    {
                        PropertyDef = 100,
                        TypedValue = new TypedValue { DataType = MFDataType.Lookup,  Lookup = new Lookup { Item = GetObjectClassID("Contactpersoon"), Version=-1 } }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetContpersPropertyID("Contact naam"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = contpers.LastName }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetContpersPropertyID("Contact voornaam"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = contpers.FirstName }
                    },
                    new PropertyValue
                    {
                        PropertyDef = GetContpersPropertyID("Contact email"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = contpers.Email }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  AllProperties.Where(val => val.Name == "Eigenaar (Relatie)").Select(val => val.ID).FirstOrDefault(),
                        TypedValue = new TypedValue{ DataType = MFDataType.Lookup, Lookup = new Lookup
                            {
                                Item = relNum, Version = -1
                            }
                        }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetContpersPropertyID("Contactpersoon Status"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = contpers.Status }
                    },
                    new PropertyValue
                    {
                        PropertyDef =  GetContpersPropertyID("Contact ID"),
                        TypedValue = new TypedValue{ DataType = MFDataType.Text, Value = contpers.ID }
                    }
                }
            };

            if (relNum == 0)
            {
                creationInfo.PropertyValues.ToList().RemoveAll(v => v.PropertyDef == GetArchiveKeyPropertyID("Relatie"));
            }
            return creationInfo;
        }

        public HashSet<PropertyValue> CompareArchiveKey(Archive updatedArchive, ObjectVersion oldArchive)
        {
            ObjectCreationInfo creationInfo = CreateNewArchiveKey(updatedArchive);
            PropertyValue[] propertiesOldArchive = GetPropertiesOfObject(oldArchive, "Archiefkey");

            return CompareObject(propertiesOldArchive, creationInfo);
        }

        public HashSet<PropertyValue> CompareRelation(Relation updatedRelation, ObjectVersion oldRelation)
        {
            ObjectCreationInfo creationInfo = CreateNewRelation(updatedRelation);
            PropertyValue[] propertiesOldRelation = GetPropertiesOfObject(oldRelation, "Relatie");

            return CompareObject(propertiesOldRelation, creationInfo);
        }

        public HashSet<PropertyValue> CompareContpers(Contpers updatedContpers, ObjectVersion oldContpers)
        {
            ObjectCreationInfo creationInfo = CreateNewContpers(updatedContpers);
            PropertyValue[] propertiesOldContpers = GetPropertiesOfObject(oldContpers, "Contactpersoon");

            return CompareObject(propertiesOldContpers, creationInfo);
        }

        private HashSet<PropertyValue> CompareObject(PropertyValue[] oldProperties, ObjectCreationInfo newProperties)
        {
            bool changeDetected = false;
            HashSet<PropertyValue> changedProperties = new HashSet<PropertyValue>();

            foreach (PropertyValue property in oldProperties)
            {
                PropertyValue value = newProperties.PropertyValues.Where(prop => prop.PropertyDef == property.PropertyDef).FirstOrDefault(); //PropertyDef = 100 is number for the objectClass

                if (value != null)
                {
                    changeDetected = false;

                    if (value.TypedValue.DataType != MFDataType.Lookup && value.TypedValue.DataType != MFDataType.MultiSelectLookup && value.TypedValue.DataType != MFDataType.Date)
                    {
                        changeDetected = !value.TypedValue.Value.Equals(property.TypedValue.Value);
                        if (value.TypedValue.Value.ToString() == "" && property.TypedValue.Value == null)
                            changeDetected = false;
                    }
                    else if (value.TypedValue.DataType == MFDataType.Lookup)
                        changeDetected = value.TypedValue.Lookup.Item != property.TypedValue.Lookup.Item;
                    else if (value.TypedValue.DataType == MFDataType.MultiSelectLookup)
                    {
                        if (property.TypedValue.Lookups != null && value.TypedValue.Lookups != null)
                        {
                            for (int i = 0; i < value.TypedValue.Lookups.Length; i++)
                            {
                                changeDetected = true;
                                for (int j = 0; j < property.TypedValue.Lookups.Length; j++)
                                {
                                    if (value.TypedValue.Lookups[i].Item == property.TypedValue.Lookups[j].Item)
                                    {
                                        changeDetected = false;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    else if (value.TypedValue.DataType == MFDataType.Date)
                    {
                        changeDetected = !value.TypedValue.Value.ToString().Contains(property.TypedValue.DisplayValue.ToString());
                    }

                    if (changeDetected)
                    {
                        changedProperties.Add(value);
                    }
                }
            }

            changedProperties.Remove(changedProperties.Where(prop => prop.TypedValue.DataType == MFDataType.Lookup).Where(propval => propval.TypedValue.Lookup == null || propval.TypedValue.Lookup.Item == 0).FirstOrDefault());
            changedProperties.Remove(changedProperties.Where(prop => prop.TypedValue.DataType == MFDataType.MultiSelectLookup).Where(propval => propval.TypedValue.Lookups == null || propval.TypedValue.Lookups.Where(val => val.Item == 0).Count() != 0).FirstOrDefault());

            return changedProperties;
        }

        public ObjectVersion PostUpdatedProperties(string objectType, ObjectVersion oldObject, HashSet<PropertyValue> changedProperties)
        {
            int objectTypeID = GetObjectTypeID(objectType);
            int objectID = oldObject.ObjVer.ID;

            if (changedProperties.Count != 0)
            {
                CheckOutItem(objectTypeID, oldObject);

                WebResponse response = null;

                foreach (PropertyValue property in changedProperties)
                {
                    string url = String.Format("http://{0}/REST/objects/{1}/{2}/properties/{3}?_method=PUT", mFLogin.Server, objectTypeID, objectID, property.PropertyDef);
                    response = PostObject<PropertyValue>(url, property);
                }

                if (response != null)
                {
                    var createdObject = GetPostResult<ObjectVersion>(response);

                    CheckInItem(objectTypeID, createdObject);
                    NotifyObservers(objectType, createdObject.Title, "UPDATE", "MFILES");

                    return createdObject;
                }
                else
                    return PostUpdatedProperties(objectType, oldObject, changedProperties);
            }

            return default(ObjectVersion);
        }

        #endregion M-FILES

        #region Observer
        public void RegisterObserver(Observer observer)
        {
            if (!observerList.Contains(observer))
                observerList.Add(observer);
        }

        public void RemoveObserver(Observer observer)
        {
            if(observerList.Contains(observer))
                observerList.Remove(observer);
        }

        public void NotifyObservers(ServiceStatus serviceStatus)
        {
            foreach (Observer o in observerList)
                o.Update(serviceStatus);
        }

        public void NotifyObservers(string table, string newObject, string changeType, string program)
        {
            foreach (Observer o in observerList)
                o.Update(table, newObject, changeType, program);
        }

        public void NotifyObservers(string documentTitle, string errorMessage, string error)
        {
            WriteError(DateTime.Now, documentTitle, errorMessage, error);
            foreach (Observer oc in observerList)
            {
                oc.UpdateError(DateTime.Now, documentTitle, errorMessage, error);
            }
        }


        public void WriteError(DateTime occuredAt, string documentTitle, string errorMessage, string error)
        {
            string directoryPath = @".\Log";
            string filePath = @".\Log\Error.txt";

            Directory.CreateDirectory(directoryPath);

            using (StreamWriter writer = new StreamWriter(filePath, true))
            {
                writer.WriteLine("Document: " + documentTitle + Environment.NewLine
                    + "Error: " + error + Environment.NewLine
                    + "Error description: " + errorMessage +
                   "" + Environment.NewLine + "Date: " + occuredAt.ToString());
                writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
            }
        }

        public void WriteToLog(DateTime occuredAt, string program, string table, string documentTitle, string type)
        {
            string directoryPath = @".\Log";
            string filePath = @".\Log\Log.txt";

            Directory.CreateDirectory(directoryPath);

            using (StreamWriter writer = new StreamWriter(filePath, true))
            {
                writer.WriteLine("Document: " + documentTitle + Environment.NewLine
                    + "SQL/M-Files: " + program + Environment.NewLine
                    + "Type: " + type + Environment.NewLine
                    + "Table/ObjectType: " + table +
                   "" + Environment.NewLine + "Date: " + occuredAt.ToString());
                writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
            }
        }
        #endregion Observer
    }
}