/*
 *
 * (c) Copyright Ascensio System Limited 2010-2018
 *
 * This program is freeware. You can redistribute it and/or modify it under the terms of the GNU 
 * General Public License (GPL) version 3 as published by the Free Software Foundation (https://www.gnu.org/copyleft/gpl.html). 
 * In accordance with Section 7(a) of the GNU GPL its Section 15 shall be amended to the effect that 
 * Ascensio System SIA expressly excludes the warranty of non-infringement of any third-party rights.
 *
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR
 * FITNESS FOR A PARTICULAR PURPOSE. For more details, see GNU GPL at https://www.gnu.org/copyleft/gpl.html
 *
 * You can contact Ascensio System SIA by email at sales@onlyoffice.com
 *
 * The interactive user interfaces in modified source and object code versions of ONLYOFFICE must display 
 * Appropriate Legal Notices, as required under Section 5 of the GNU GPL version 3.
 *
 * Pursuant to Section 7 § 3(b) of the GNU GPL you must retain the original ONLYOFFICE logo which contains 
 * relevant author attributions when distributing the software. If the display of the logo in its graphic 
 * form is not reasonably feasible for technical reasons, you must include the words "Powered by ONLYOFFICE" 
 * in every copy of the program you distribute. 
 * Pursuant to Section 7 § 3(e) we decline to grant you any rights under trademark law for use of our trademarks.
 *
*/


using ASC.Api.Core;
using ASC.CRM.ApiModels;
using ASC.Api.Documents;
using ASC.Common.Web;
using ASC.CRM.Core;
using ASC.CRM.Core.Entities;
using ASC.CRM.Core.Enums;
using ASC.MessagingSystem;
using ASC.Web.Api.Routing;
using ASC.Web.Files.Utils;

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

using OrderBy = ASC.CRM.Core.Entities.OrderBy;
using ASC.Api.CRM;
using ASC.CRM.Core.Dao;
using ASC.Web.CRM.Services.NotifyService;
using ASC.Core;
using ASC.Web.Core.Users;

namespace ASC.CRM.Api
{
    public class RelationshipEventsController : BaseApiController
    {
        public RelationshipEventsController(CRMSecurity cRMSecurity,
                     DaoFactory daoFactory,
                     ApiContext apiContext,
                     MessageTarget messageTarget,
                     MessageService messageService,
                     ContactDtoHelper contactBaseDtoHelper,
                     RelationshipEventDtoHelper relationshipEventDtoHelper,
                     FileWrapperHelper fileWrapperHelper,
                     ASC.Files.Core.Data.DaoFactory filesDaoFactory,
                     FileUploader fileUploader,
                     HistoryCategoryDtoHelper historyCategoryDtoHelper)
            : base(daoFactory, cRMSecurity)
        {
            ApiContext = apiContext;
            MessageTarget = messageTarget;
            MessageService = messageService;
            ContactDtoHelper = contactBaseDtoHelper;
            RelationshipEventDtoHelper = relationshipEventDtoHelper;
            FileWrapperHelper = fileWrapperHelper;
            FilesDaoFactory = filesDaoFactory;
            FileUploader = fileUploader;
            HistoryCategoryDtoHelper = historyCategoryDtoHelper;
        }

        public HistoryCategoryDtoHelper HistoryCategoryDtoHelper { get; }
        public FileUploader FileUploader { get; }
        public ASC.Files.Core.Data.DaoFactory FilesDaoFactory { get; set; }
        public FileWrapperHelper FileWrapperHelper { get; }
        public RelationshipEventDtoHelper RelationshipEventDtoHelper { get; }
        public ContactDtoHelper ContactDtoHelper { get; }
        private ApiContext ApiContext { get; }
        public MessageService MessageService { get; }
        public MessageTarget MessageTarget { get; }
    
        /// <summary>
        ///   Returns the list of all events matching the parameters specified in the request
        /// </summary>
        /// <short>
        ///   Get event list
        /// </short>
        /// <category>History</category>
        /// <param optional="true" name="entityType" remark="Allowed values: opportunity, contact or case">Related entity type</param>
        /// <param optional="true" name="entityId">Related entity ID</param>
        /// <param optional="true" name="categoryId">Task category ID</param>
        /// <param optional="true" name="createBy">Event author</param>
        /// <param optional="true" name="fromDate">Earliest task due date</param>
        /// <param optional="true" name="toDate">Latest task due date</param>
        /// <returns>
        ///   Event list
        /// </returns>
        [Read(@"history/filter")]
        public IEnumerable<RelationshipEventDto> GetHistory(
            string entityType,
            int entityId,
            int categoryId,
            Guid createBy,
            ApiDateTime fromDate,
            ApiDateTime toDate)
        {
            var entityTypeObj = ToEntityType(entityType);

            switch (entityTypeObj)
            {
                case EntityType.Contact:
                    var contact = DaoFactory.GetContactDao().GetByID(entityId);
                    if (contact == null || !CRMSecurity.CanAccessTo(contact))
                        throw new ItemNotFoundException();
                    break;
                case EntityType.Case:
                    var cases = DaoFactory.GetCasesDao().GetByID(entityId);
                    if (cases == null || !CRMSecurity.CanAccessTo(cases))
                        throw new ItemNotFoundException();
                    break;
                case EntityType.Opportunity:
                    var deal = DaoFactory.GetDealDao().GetByID(entityId);
                    if (deal == null || !CRMSecurity.CanAccessTo(deal))
                        throw new ItemNotFoundException();
                    break;
                default:
                    if (entityId != 0)
                    {
                        throw new ArgumentException();
                    }
                    break;
            }

            RelationshipEventByType eventByType;

            IEnumerable<RelationshipEventDto> result;

            OrderBy eventOrderBy;

            if (ASC.CRM.Classes.EnumExtension.TryParse(ApiContext.SortBy, true, out eventByType))
            {
                eventOrderBy = new OrderBy(eventByType, !ApiContext.SortDescending);
            }
            else if (string.IsNullOrEmpty(ApiContext.SortBy))
            {
                eventOrderBy = new OrderBy(RelationshipEventByType.Created, false);
            }
            else
            {
                eventOrderBy = null;
            }

            if (eventOrderBy != null)
            {
                result = ToListRelationshipEventDto(DaoFactory.GetRelationshipEventDao().GetItems(
                    ApiContext.FilterValue,
                    entityTypeObj,
                    entityId,
                    createBy,
                    categoryId,
                    fromDate,
                    toDate,
                    (int)ApiContext.StartIndex,
                    (int)ApiContext.Count,
                    eventOrderBy));

                ApiContext.SetDataPaginated();
                ApiContext.SetDataFiltered();
                ApiContext.SetDataSorted();
            }
            else
            {
                result = ToListRelationshipEventDto(DaoFactory.GetRelationshipEventDao().GetItems(
                    ApiContext.FilterValue,
                    entityTypeObj,
                    entityId,
                    createBy,
                    categoryId,
                    fromDate,
                    toDate,
                    0,
                    0,
                    null));
            }

            return result;
        }

        /// <summary>
        ///     Deletes the event with the ID specified in the request and all the files associated with this event
        /// </summary>
        /// <short>
        ///     Delete event and related files
        /// </short>
        /// <category>History</category>
        /// <param name="id">Event ID</param>
        /// <exception cref="ArgumentException"></exception>
        /// <exception cref="ItemNotFoundException"></exception>
        /// <returns>
        ///   Event
        /// </returns>
        [Delete(@"history/{id:int}")]
        public RelationshipEventDto DeleteHistory(int id)
        {
            if (id <= 0) throw new ArgumentException();

            var item = DaoFactory.GetRelationshipEventDao().GetByID(id);
            if (item == null) throw new ItemNotFoundException();
            var wrapper = RelationshipEventDtoHelper.Get(item);

            DaoFactory.GetRelationshipEventDao().DeleteItem(id);

            var messageAction = GetHistoryDeletedAction(item.EntityType, item.ContactID);
            var entityTitle = wrapper.Contact == null ? wrapper.Entity.EntityTitle : wrapper.Contact.DisplayName;
            MessageService.Send(messageAction, MessageTarget.Create(item.ID), entityTitle, wrapper.Category.Title);

            return wrapper;
        }

        /// <summary>
        /// Creates a text (.txt) file in the selected folder with the title and contents sent in the request
        /// </summary>
        /// <short>Create txt</short>
        /// <category>Files</category>
        /// <param name="entityType">Entity type</param>
        /// <param name="entityid">Entity ID</param>
        /// <param name="title">File title</param>
        /// <param name="content">File contents</param>
        /// <returns>
        ///     File info
        /// </returns>
        [Create(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files/text")]
        public FileWrapper<int> CreateTextFile(string entityType, int entityid, string title, string content)
        {
            if (title == null) throw new ArgumentNullException("title");
            if (content == null) throw new ArgumentNullException("content");

            var folderid = GetRootFolderID();

            FileWrapper<int> result;

            var extension = ".txt";
            if (!string.IsNullOrEmpty(content))
            {
                if (Regex.IsMatch(content, @"<([^\s>]*)(\s[^<]*)>"))
                {
                    extension = ".html";
                }
            }

            using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            {
                title = title.EndsWith(extension, StringComparison.OrdinalIgnoreCase) ? title : (title + extension);
                result = SaveFile(folderid, memStream, title);
            }

            AttachFiles(entityType, entityid, new List<int> { (int)result.Id });

            return result;
        }

        /// <summary>
        /// Upload file 
        /// </summary>
        /// <short>Upload file</short>
        /// <category>Files</category>
        /// <remarks>
        /// <![CDATA[
        ///  Upload can be done in 2 different ways:
        ///  <ol>
        /// <li>Single file upload. You should set Content-Type &amp; Content-Disposition header to specify filename and content type, and send file in request body</li>
        /// <li>Using standart multipart/form-data method</li>
        /// </ol>]]>
        /// </remarks>
        /// <param name="entityType">Entity type</param>
        /// <param name="entityid">Entity ID</param>
        /// <param name="file" visible="false">Request Input stream</param>
        /// <param name="contentType" visible="false">Content-Type Header</param>
        /// <param name="contentDisposition" visible="false">Content-Disposition Header</param>
        /// <param name="files" visible="false">List of files when posted as multipart/form-data</param>
        /// <param name="storeOriginalFileFlag" visible="false">If True, upload documents in original formats as well</param>
        /// <returns>
        /// File info
        /// </returns>
        //[Create(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files/upload")]
        //public FileWrapper<int> UploadFileInCRM(
        //    string entityType,
        //    int entityid,
        //    Stream file,
        //    ContentType contentType,
        //    ContentDisposition contentDisposition,
        //    IEnumerable<IFormFile> files,
        //    bool storeOriginalFileFlag
        //    )
        //{
        //    FilesSettings.StoreOriginalFilesSetting = storeOriginalFileFlag;

        //    var folderid = GetRootFolderID();

        //    var fileNames = new List<string>();

        //    FileWrapper<int> uploadedFile = null;
        //    if (files != null && files.Any())
        //    {
        //        //For case with multiple files
        //        foreach (var postedFile in files)
        //        {
        //            using var fileStream = postedFile.OpenReadStream();
        //            uploadedFile = SaveFile(folderid, fileStream, postedFile.FileName);
        //            fileNames.Add(uploadedFile.Title);
        //        }
        //    }
        //    else if (file != null)
        //    {
        //        uploadedFile = SaveFile(folderid, file, contentDisposition.FileName);
        //        fileNames.Add(uploadedFile.Title);
        //    }

        //    return uploadedFile;
        //}

        private FileWrapper<int> SaveFile(int folderid, Stream file, string fileName)
        {
            var resultFile = FileUploader.Exec<int>(folderid, fileName, file.Length, file);

            return FileWrapperHelper.Get<int>(resultFile);
        }

        /// <summary>
        ///   Creates the event with the parameters specified in the request
        /// </summary>
        /// <short>
        ///   Create event
        /// </short>
        /// <category>History</category>
        /// <param optional="true" name="contactId">Contact ID</param>
        /// <param optional="true" name="entityType" remark="Allowed values: opportunity or case">Related entity type</param>
        /// <param optional="true" name="entityId">Related entity ID</param>
        /// <remarks>
        /// <![CDATA[
        ///  You should obligatorily set the value for 'contactId' if 'entityId' is not set or the value for parameters 'entityId' and 'entityType' if 'contactId' is not set.
        /// ]]>
        /// </remarks>
        /// <param optional="false" name="content">Contents</param>
        /// <param optional="false" name="categoryId">Category ID</param>
        /// <param optional="true" name="created">Event creation date</param>
        /// <param optional="true" name="fileId">List of IDs of the files associated with the event</param>
        /// <param optional="true" name="notifyUserList">User field list</param>
        /// <returns>
        ///   Created event
        /// </returns>
        //[Create(@"history")]
        //public RelationshipEventDto AddHistoryTo(
        //    string entityType,
        //    int entityId,
        //    int contactId,
        //    string content,
        //    int categoryId,
        //    ApiDateTime created,
        //    IEnumerable<int> fileId,
        //    IEnumerable<Guid> notifyUserList)
        //{
        //    if (!string.IsNullOrEmpty(entityType) &&
        //        !(
        //             string.Compare(entityType, "opportunity", StringComparison.OrdinalIgnoreCase) == 0 ||
        //             string.Compare(entityType, "case", StringComparison.OrdinalIgnoreCase) == 0)
        //        )
        //        throw new ArgumentException();

        //    var entityTypeObj = ToEntityType(entityType);

        //    var entityTitle = "";
        //    if (contactId > 0) {
        //        var contact = DaoFactory.GetContactDao().GetByID(contactId);
        //        if (contact == null || !CRMSecurity.CanAccessTo(contact))
        //            throw new ArgumentException();
        //        entityTitle = contact.GetTitle();
        //    }

        //    if (entityTypeObj == EntityType.Case) {
        //        var cases = DaoFactory.GetCasesDao().GetByID(entityId);
        //        if (cases == null || !CRMSecurity.CanAccessTo(cases))
        //            throw new ArgumentException();
        //        if (contactId <= 0)
        //        {
        //            entityTitle = cases.Title;
        //        }
        //    }
        //    if (entityTypeObj == EntityType.Opportunity)
        //    {
        //        var deal = DaoFactory.GetDealDao().GetByID(entityId);
        //        if (deal == null || !CRMSecurity.CanAccessTo(deal))
        //            throw new ArgumentException();
        //        if (contactId <= 0)
        //        {
        //            entityTitle = deal.Title;
        //        }
        //    }

        //    var relationshipEvent = new RelationshipEvent
        //        {
        //            CategoryID = categoryId,
        //            EntityType = entityTypeObj,
        //            EntityID = entityId,
        //            Content = content,
        //            ContactID = contactId,
        //            CreateOn = created,
        //            CreateBy = SecurityContext.CurrentAccount.ID
        //        };

        //    var category = DaoFactory.GetListItemDao().GetByID(categoryId);
        //    if (category == null) throw new ArgumentException();

        //    var item = DaoFactory.GetRelationshipEventDao().CreateItem(relationshipEvent);


        //    notifyUserList = notifyUserList != null ? notifyUserList.ToList() : new List<Guid>();
        //    var needNotify = notifyUserList.Any();

        //    var fileListInfoHashtable = new Hashtable();

        //    if (fileId != null)
        //    {
        //        var fileIds = fileId.ToList();
        //        var files = FilesDaoFactory.GetFileDao<int>().GetFiles(fileIds.ToArray());

        //        if (needNotify)
        //        {
        //            foreach (var file in files)
        //            {
        //                var extension = Path.GetExtension(file.Title);
        //                if (extension == null) continue;

        //                var fileInfo = string.Format("{0} ({1})", file.Title, extension.ToUpper());
        //                if (!fileListInfoHashtable.ContainsKey(fileInfo))
        //                {
        //                    fileListInfoHashtable.Add(fileInfo, file.DownloadUrl);
        //                }
        //                else
        //                {
        //                    fileInfo = string.Format("{0} ({1}, {2})", file.Title, extension.ToUpper(), file.UniqID);
        //                    fileListInfoHashtable.Add(fileInfo, file.DownloadUrl);
        //                }
        //            }
        //        }

        //        DaoFactory.GetRelationshipEventDao().AttachFiles(item.ID, fileIds.ToArray());

        //        if (files.Any())
        //        {
        //            var fileAttachAction = GetFilesAttachAction(entityTypeObj, contactId);
        //            MessageService.Send( fileAttachAction, MessageTarget.Create(item.ID), entityTitle, files.Select(x => x.Title));
        //        }
        //    }

        //    if (needNotify)
        //    {
        //        NotifyClient.SendAboutAddRelationshipEventAdd(item, fileListInfoHashtable, DaoFactory, notifyUserList.ToArray());
        //    }

        //    var wrapper = RelationshipEventDtoHelper.Get(item);

        //    var historyCreatedAction = GetHistoryCreatedAction(entityTypeObj, contactId);
        //    MessageService.Send( historyCreatedAction, MessageTarget.Create(item.ID), entityTitle, category.Title);

        //    return wrapper;
        //}

        /// <summary>
        ///     Associates the selected file(s) with the entity with the ID or type specified in the request
        /// </summary>
        /// <short>
        ///     Associate file with entity
        /// </short>
        /// <param name="entityType">Entity type</param>
        /// <param name="entityid">Entity ID</param>
        /// <param name="fileids">List of IDs of the files</param>
        /// <category>Files</category>
        /// <returns>Entity with the file attached</returns>
        [Create(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files")]
        public RelationshipEventDto AttachFiles(string entityType, int entityid, IEnumerable<int> fileids)
        {
            if (entityid <= 0 || fileids == null) throw new ArgumentException();

            var files = FilesDaoFactory.GetFileDao<int>().GetFiles(fileids.ToArray());

            var folderid = GetRootFolderID();

            if (files.Exists(file => file.FolderID.ToString() != folderid.ToString()))
                throw new ArgumentException("invalid file folder");

            var entityTypeObj = ToEntityType(entityType);

            DomainObject entityObj;

            var entityTitle = GetEntityTitle(entityTypeObj, entityid, true, out entityObj);

            switch (entityTypeObj)
            {
                case EntityType.Contact:
                    var relationshipEvent1 = DaoFactory.GetRelationshipEventDao().AttachFiles(entityid, EntityType.Any, 0, fileids.ToArray());
                    var messageAction = entityObj is Company ? MessageAction.CompanyAttachedFiles : MessageAction.PersonAttachedFiles;
                    MessageService.Send(messageAction, MessageTarget.Create(entityid), entityTitle, files.Select(x => x.Title));
                    return RelationshipEventDtoHelper.Get(relationshipEvent1);
                case EntityType.Opportunity:
                    var relationshipEvent2 = DaoFactory.GetRelationshipEventDao().AttachFiles(0, entityTypeObj, entityid, fileids.ToArray());
                    MessageService.Send(MessageAction.OpportunityAttachedFiles, MessageTarget.Create(entityid), entityTitle, files.Select(x => x.Title));
                    return RelationshipEventDtoHelper.Get(relationshipEvent2);
                case EntityType.Case:
                    var relationshipEvent3 = DaoFactory.GetRelationshipEventDao().AttachFiles(0, entityTypeObj, entityid, fileids.ToArray());
                    MessageService.Send(MessageAction.CaseAttachedFiles, MessageTarget.Create(entityid), entityTitle, files.Select(x => x.Title));
                    return RelationshipEventDtoHelper.Get(relationshipEvent3);
                default:
                    throw new ArgumentException();
            }
        }

        /// <summary>
        ///     Returns the ID for the root folder used to store the files for the CRM module
        /// </summary>
        /// <short>Get root folder ID</short> 
        /// <category>Files</category>
        /// <returns>
        ///   Root folder ID
        /// </returns>
        [Read(@"files/root")]
        public int GetRootFolderID()
        {
            return DaoFactory.GetFileDao().GetRoot();
        }

        /// <summary>
        ///    Returns the list of all files for the entity with the ID or type specified in the request
        /// </summary>
        /// <param name="entityType">Entity type</param>
        /// <param name="entityid">Entity ID</param>
        /// <short>Get file list</short> 
        /// <category>Files</category>
        /// <returns>
        ///    File list
        /// </returns>
        [Read(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files")]
        public IEnumerable<FileWrapper<int>> GetFiles(string entityType, int entityid)
        {
            if (entityid <= 0) throw new ArgumentException();

            var entityTypeObj = ToEntityType(entityType);

            switch (entityTypeObj)
            {
                case EntityType.Contact:
                    return DaoFactory.GetRelationshipEventDao().GetAllFiles(new[] { entityid }, EntityType.Any, 0).ConvertAll(file => FileWrapperHelper.Get<int>(file));
                case EntityType.Opportunity:
                case EntityType.Case:
                    return DaoFactory.GetRelationshipEventDao().GetAllFiles(null, entityTypeObj, entityid).ConvertAll(file => FileWrapperHelper.Get<int>(file));
                default:
                    throw new ArgumentException();
            }
        }

        /// <summary>
        ///     Deletes the file with the ID specified in the request
        /// </summary>
        /// <short>Delete file</short> 
        /// <category>Files</category>
        /// <param name="fileid">File ID</param>
        /// <exception cref="ArgumentException"></exception>
        /// <exception cref="ItemNotFoundException"></exception>
        /// <returns>
        ///    File Info
        /// </returns>
        [Delete(@"files/{fileid:int}")]
        public FileWrapper<int> DeleteCRMFile(int fileid)
        {
            if (fileid < 0) throw new ArgumentException();

            var file = FilesDaoFactory.GetFileDao<int>().GetFile(fileid);
            if (file == null) throw new ItemNotFoundException();
            var result = FileWrapperHelper.Get<int>(file);

            var _eventsDao = DaoFactory.GetRelationshipEventDao();
            var eventIDs = _eventsDao.RemoveFile(file);
            var events = new List<RelationshipEvent>();

            eventIDs.ForEach(id => events.Add(_eventsDao.GetByID(id)));

            foreach (var evt in events)
            {
                DomainObject entityObj;
                var entityTitle = evt.ContactID > 0
                                  ? GetEntityTitle(EntityType.Contact, evt.ContactID, false, out entityObj)
                                  : GetEntityTitle(evt.EntityType, evt.EntityID, false, out entityObj);
                var messageAction = GetFilesDetachAction(evt.EntityType, evt.ContactID);

                MessageService.Send(messageAction, MessageTarget.Create(file.ID), entityTitle, file.Title);
            }

            return result;
        }

        private IEnumerable<RelationshipEventDto> ToListRelationshipEventDto(List<RelationshipEvent> itemList)
        {
            if (itemList.Count == 0) return new List<RelationshipEventDto>();

            var result = new List<RelationshipEventDto>();

            var contactIDs = new List<int>();
            var eventIDs = new List<int>();
            var categoryIDs = new List<int>();
            var entityDtosIDs = new Dictionary<EntityType, List<int>>();


            foreach (var item in itemList)
            {
                eventIDs.Add(item.ID);

                if (!categoryIDs.Contains(item.CategoryID))
                {
                    categoryIDs.Add(item.CategoryID);
                }

                if (item.ContactID > 0 && !contactIDs.Contains(item.ContactID))
                {
                    contactIDs.Add(item.ContactID);
                }

                if (item.EntityID <= 0) continue;

                if (!entityDtosIDs.ContainsKey(item.EntityType))
                {
                    entityDtosIDs.Add(item.EntityType, new List<int>
                        {
                            item.EntityID
                        });
                }
                else if (!entityDtosIDs[item.EntityType].Contains(item.EntityID))
                {
                    entityDtosIDs[item.EntityType].Add(item.EntityID);
                }
            }

            var entityDtos = new Dictionary<string, EntityDto>();

            foreach (var entityType in entityDtosIDs.Keys)
            {
                switch (entityType)
                {
                    case EntityType.Opportunity:
                        DaoFactory.GetDealDao().GetDeals(entityDtosIDs[entityType].Distinct().ToArray())
                                  .ForEach(item =>
                                      {
                                          if (item == null) return;

                                          entityDtos.Add(
                                              string.Format("{0}_{1}", (int)entityType, item.ID),
                                              new EntityDto
                                              {
                                                  EntityId = item.ID,
                                                  EntityTitle = item.Title,
                                                  EntityType = "opportunity"
                                              });
                                      });
                        break;
                    case EntityType.Case:
                        DaoFactory.GetCasesDao().GetByID(entityDtosIDs[entityType].ToArray())
                                  .ForEach(item =>
                                      {
                                          if (item == null) return;

                                          entityDtos.Add(
                                              string.Format("{0}_{1}", (int)entityType, item.ID),
                                              new EntityDto
                                              {
                                                  EntityId = item.ID,
                                                  EntityTitle = item.Title,
                                                  EntityType = "case"
                                              });
                                      });
                        break;
                    default:
                        throw new ArgumentException();
                }
            }

            var categories = DaoFactory.GetListItemDao().GetItems(categoryIDs.ToArray()).ToDictionary(x => x.ID, x => HistoryCategoryDtoHelper.Get(x));

            var files = DaoFactory.GetRelationshipEventDao().GetFiles(eventIDs.ToArray());

            var contacts = DaoFactory.GetContactDao().GetContacts(contactIDs.ToArray()).ToDictionary(item => item.ID, x => ContactDtoHelper.GetContactBaseDto(x));

            foreach (var item in itemList)
            {
                var eventObjWrap = RelationshipEventDtoHelper.Get(item);

                if (contacts.ContainsKey(item.ContactID))
                {
                    eventObjWrap.Contact = contacts[item.ContactID];
                }

                if (item.EntityID > 0)
                {
                    var entityStrKey = string.Format("{0}_{1}", (int)item.EntityType, item.EntityID);

                    if (entityDtos.ContainsKey(entityStrKey))
                    {
                        eventObjWrap.Entity = entityDtos[entityStrKey];
                    }
                }

                eventObjWrap.Files = files.ContainsKey(item.ID) ? files[item.ID].ConvertAll(file =>
                FileWrapperHelper.Get<int>(file)) : new List<FileWrapper<int>>();

                if (categories.ContainsKey(item.CategoryID))
                {
                    eventObjWrap.Category = categories[item.CategoryID];
                }

                result.Add(eventObjWrap);
            }

            return result;
        }

  

        private MessageAction GetHistoryCreatedAction(EntityType entityType, int contactId)
        {
            if (contactId > 0)
            {
                var contact = DaoFactory.GetContactDao().GetByID(contactId);
                return contact is Company ? MessageAction.CompanyCreatedHistoryEvent : MessageAction.PersonCreatedHistoryEvent;
            }

            switch (entityType)
            {
                case EntityType.Opportunity:
                    return MessageAction.OpportunityCreatedHistoryEvent;
                case EntityType.Case:
                    return MessageAction.CaseCreatedHistoryEvent;
                case EntityType.Any:
                    var contact = DaoFactory.GetContactDao().GetByID(contactId);
                    return contact is Company ? MessageAction.CompanyCreatedHistoryEvent : MessageAction.PersonCreatedHistoryEvent;
                default:
                    throw new ArgumentException("Invalid entityType: " + entityType);
            }
        }

        private MessageAction GetHistoryDeletedAction(EntityType entityType, int contactId)
        {
            if (contactId > 0)
            {
                var contact = DaoFactory.GetContactDao().GetByID(contactId);
                return contact is Company ? MessageAction.CompanyDeletedHistoryEvent : MessageAction.PersonDeletedHistoryEvent;
            }

            switch (entityType)
            {
                case EntityType.Opportunity:
                    return MessageAction.OpportunityDeletedHistoryEvent;
                case EntityType.Case:
                    return MessageAction.CaseDeletedHistoryEvent;
                case EntityType.Any:
                    var contact = DaoFactory.GetContactDao().GetByID(contactId);
                    return contact is Company ? MessageAction.CompanyDeletedHistoryEvent : MessageAction.PersonDeletedHistoryEvent;
                default:
                    throw new ArgumentException("Invalid entityType: " + entityType);
            }
        }

        private MessageAction GetFilesAttachAction(EntityType entityType, int contactId)
        {
            if (contactId > 0)
            {
                var contact = DaoFactory.GetContactDao().GetByID(contactId);
                return contact is Company ? MessageAction.CompanyAttachedFiles : MessageAction.PersonAttachedFiles;
            }

            switch (entityType)
            {
                case EntityType.Opportunity:
                    return MessageAction.OpportunityAttachedFiles;
                case EntityType.Case:
                    return MessageAction.CaseAttachedFiles;
                case EntityType.Any:
                    var contact = DaoFactory.GetContactDao().GetByID(contactId);
                    return contact is Company ? MessageAction.CompanyAttachedFiles : MessageAction.PersonAttachedFiles;
                default:
                    throw new ArgumentException("Invalid entityType: " + entityType);
            }
        }

        private MessageAction GetFilesDetachAction(EntityType entityType, int contactId)
        {
            if (contactId > 0)
            {
                var contact = DaoFactory.GetContactDao().GetByID(contactId);
                return contact is Company ? MessageAction.CompanyDetachedFile : MessageAction.PersonDetachedFile;
            }

            switch (entityType)
            {
                case EntityType.Opportunity:
                    return MessageAction.OpportunityDetachedFile;
                case EntityType.Case:
                    return MessageAction.CaseDetachedFile;
                case EntityType.Any:
                    var contact = DaoFactory.GetContactDao().GetByID(contactId);
                    return contact is Company ? MessageAction.CompanyDetachedFile : MessageAction.PersonAttachedFiles;
                default:
                    throw new ArgumentException("Invalid entityType: " + entityType);
            }
        }
    }
}