MARKUS

using Markus.Message;

using Markus.Service.Extensions;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

namespace Markus.Service.DataBase

{

    public class ConvertDatabase : IDisposable

    {

        MarkusEntities entities;

        public ConvertDatabase(string ConnectionString)

        {

            try

            {

                //해당 프로젝트의 데이터베이스 연결

                string databaseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Database");

                entities = new MarkusEntities(ConnectionString);

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex.ToString());

                throw;

            }

        }

        public void Dispose()

        {

            entities.Dispose();

        }

        /// <summary>

        /// 컨버터서비스를 이용하는 문서 정보 저장

        /// UniqueID

        /// using Markus.Service.Extensions;  new Guid().CreateUniqueGuid().ToString();

        /// </summary>

        /// <param name="ProjectNo">프로젝트</param>

        /// <param name="UniqueID">컨버터 서비스의 아이템 ID</param>

        /// <param name="originfilePath"></param>

        /// <param name="DocumentID"></param>

        /// <returns></returns>

        public bool SetConvertDoc(string ProjectNo, string UniqueID, string originfilePath, string DocumentID)

        {

            bool result = false;

            if (ProjectNo.IsNullOrEmpty())

            {

                throw new Exception("ProjectNo is Null");

            }

            if (UniqueID.IsNullOrEmpty())

            {

                throw new Exception("UniqueID is Null");

            }

            if (originfilePath.IsNullOrEmpty())

            {

                throw new Exception("originfilePath is Null");

            }

            if (DocumentID.IsNullOrEmpty())

            {

                throw new Exception("DocumentID is Null");

            }

            if (DocumentID.IsNullOrEmpty())

            {

                long _lastDocId = 0;

                if (entities.CONVERTER_DOC.Count() > 0)

                {

                    try

                    {

                        string qry = @"SELECT * FROM CONVERTER_DOC order by CAST(DOCUMENT_ID as int) desc";

                        var _item = entities.CONVERTER_DOC.SqlQuery(qry).FirstOrDefault();

                        if (_item != null)

                        {

                            _lastDocId = Convert.ToInt64(_item.DOCUMENT_ID) + 1;

                        }

                    }

                    catch (Exception)

                    {

                        throw;

                    }

                }

                DocumentID = _lastDocId.ToString();

            }

            CONVERTER_DOC convert_doc = new CONVERTER_DOC

            {

                ID = UniqueID,

                PROJECT_NO = ProjectNo,

                DOCUMENT_URL = originfilePath,

                DOCUMENT_ID = DocumentID,

                CREATE_DATETIME = DateTime.Now,

                STATUS = 0,

                TOTAL_PAGE = 0,

                CURRENT_PAGE = 0,

                RECONVERTER = 0

            };

            entities.CONVERTER_DOC.Add(convert_doc);

            if (entities.SaveChanges() == 1)

            {

                result = true;

            }

            return result;

        }

        /// <summary>

        /// 컨버터서비스를 이용하는 문서 정보 저장

        /// UniqueID

        /// using Markus.Service.Extensions;  new Guid().CreateUniqueGuid().ToString();

        /// </summary>

        /// <param name="ProjectNo">프로젝트</param>

        /// <param name="UniqueID">컨버터 서비스의 아이템 ID</param>

        /// <param name="originfilePath"></param>

        /// <param name="DocumentID"></param>

        /// <returns></returns>

        public bool SetDocumentInfo(string ConvertID, int totalPage, List<DOCPAGE> pageinfo)

        {

            bool result = false;

            var convertDocItems = entities.CONVERTER_DOC.Where(f => f.ID == ConvertID);

            if (convertDocItems.Count() > 0)

            {

                var convertDoc = convertDocItems.First();

                var docId = new Guid().CreateUniqueGuid();

                var docinfo = entities.DOCINFO.FirstOrDefault(x => x.PROJECT_NO == convertDoc.PROJECT_NO && x.DOCUMENT_ID == convertDoc.DOCUMENT_ID);

                if (docinfo != null)

                {

                    entities.DOCPAGE.RemoveRange(docinfo.DOCPAGE);

                    entities.DOCINFO.Remove(docinfo);

                    entities.SaveChanges();

                }

                DOCINFO instace = new DOCINFO

                {

                    ID = docId.ToString(),

                    PROJECT_NO = convertDoc.PROJECT_NO,

                    ORIGINAL_FILE = convertDoc.DOCUMENT_URL,

                    DOCUMENT_ID = convertDoc.DOCUMENT_ID,

                    PAGE_COUNT = totalPage,

                    DOCPAGE = pageinfo

                };

                entities.DOCINFO.Add(instace);

                var save = entities.SaveChanges();

                if (save == pageinfo.Count() + 1)

                {

                    result = true;

                }

            }

            return result;

        }

        public Interface.ConvertItem GetConvertItem(string ProjectNo, string UniqueID)

        {

            Interface.ConvertItem result = null;

            //var items = entities.CONVERTER_DOC.Where(f => f.PROJECT_NO == gProjectNo && f.ID == UniqueID);

            var items = entities.CONVERTER_DOC.Where(f => f.PROJECT_NO == ProjectNo && f.ID == UniqueID);

            if (items.Count() > 0)

            {

                var convertItem = items.First();

                string convertPath = Path.Combine(BaseStorage(convertItem.PROJECT_NO), convertItem.PROJECT_NO + "_Tile", (System.Convert.ToInt64(convertItem.DOCUMENT_ID) / 100).ToString(), convertItem.DOCUMENT_ID);

                result = new Interface.ConvertItem(convertItem.DOCUMENT_ID, convertItem.PROJECT_NO, convertItem.ID, convertItem.DOCUMENT_URL, convertPath);

            }

            return result;

        }

        public Interface.ConvertItem GetConvertItembyDocumentID(string ProjectNo, string DocumentID)

        {

            Interface.ConvertItem result = null;

            //var items = entities.CONVERTER_DOC.Where(f => f.PROJECT_NO == gProjectNo && f.ID == UniqueID);

            var items = entities.CONVERTER_DOC.Where(f => f.PROJECT_NO == ProjectNo && f.DOCUMENT_ID == DocumentID);

            if (items.Count() > 0)

            {

                var convertItem = items.First();

                string convertPath = Path.Combine(BaseStorage(convertItem.PROJECT_NO), convertItem.PROJECT_NO + "_Tile", (System.Convert.ToInt64(convertItem.DOCUMENT_ID) / 100).ToString(), convertItem.DOCUMENT_ID);

                if (convertItem.STATUS == (int)StatusCodeType.Completed)

                {

                    result = new Interface.ConvertItem(convertItem.DOCUMENT_ID, convertItem.PROJECT_NO, convertItem.ID, convertItem.DOCUMENT_URL, convertPath,

                                                        convertItem.STATUS.ToString(), convertItem.CURRENT_PAGE, convertItem.TOTAL_PAGE, convertItem.EXCEPTION);

                }

                else

                {

                    result = new Interface.ConvertItem(convertItem.DOCUMENT_ID, convertItem.PROJECT_NO, convertItem.ID, convertItem.DOCUMENT_URL, convertPath);

                }

            }

            return result;

        }

        /// <summary>

        /// service에서 대기중이거나 오류인 아이템을 가져가서 컨버터 프로세스를 호출한다.

        /// 컨버터 상태가 에러이거나 2보다 작은 경우 

        /// UniqueKey는 각 데이터베이스의 문서 정보에서 유일한 키이며 컨버터저장에서 같은 폴더로의 저장을 방지 한다.

        /// 

        /// </summary>

        /// <param name="aliveItems"></param>

        /// <param name="TakeCount"></param>

        /// <returns></returns>

        public List<Interface.ConvertItem> GetWaitConvertItems(List<string> projectList, IEnumerable<Interface.ConvertItem> aliveItems, int TakeCount)

        {

            List<Interface.ConvertItem> convertItems = new List<Interface.ConvertItem>();

            var aliveItemList = aliveItems.Select(x => x.ProjectNumber + x.UniqueKey).ToList();

            var convertWaitingItems = entities.CONVERTER_DOC.OrderBy(x => x.CREATE_DATETIME).Where(

                                        x =>

                                        projectList.Contains(x.PROJECT_NO) &&

                                         (x.STATUS == (int)StatusCodeType.None || (x.STATUS == (int)StatusCodeType.Error && x.RECONVERTER < 2)));

            System.Diagnostics.Debug.WriteLine(convertWaitingItems.Count());

            var noneAliveItems = convertWaitingItems.Where(x =>

                                !aliveItemList.Contains(x.PROJECT_NO + x.DOCUMENT_ID));

            System.Diagnostics.Debug.WriteLine(noneAliveItems.Count());

            var items = noneAliveItems.GroupBy(f => f.DOCUMENT_ID).Select(x => x.FirstOrDefault()).Take(TakeCount).ToList();

            if (items.Count() > 0)

            {

                foreach (var convertItem in items)

                {

                    // 다시 컨버터 하는 경우

                    if (convertItem.STATUS == (int)StatusCodeType.Error)

                    {

                        convertItem.RECONVERTER = convertItem.RECONVERTER + 1;

                    }

                    // 프로세스 실행전 시작시간 추가

                    convertItem.STATUS = (int)StatusCodeType.Wait;

                    convertItem.START_DATETIME = DateTime.Now;

                    entities.SaveChanges();

                    var convertitem = new Interface.ConvertItem(convertItem.DOCUMENT_ID, convertItem.PROJECT_NO, convertItem.ID, convertItem.DOCUMENT_URL);

                    convertitem.ConvertPath = GetConvertPath(convertItem.PROJECT_NO,convertItem.DOCUMENT_ID);

                    convertItems.Add(convertitem);

                }

            }

            return convertItems;

        }

        private string GetConvertPath(string ProjectNo,string DocumentID)

        {

            try

            {

                return Path.Combine(BaseStorage(ProjectNo), ProjectNo + "_Tile", (System.Convert.ToInt64(DocumentID) / 100).ToString(), DocumentID);

            }

            catch (Exception)

            {

                throw new Exception("GetConvertPath Error");

            }

        }

        /// <summary>

        /// 오류나 wait으로 남아 있는 데이터베이스의 Item을 StatusCodeType.None으로 복구

        /// </summary>

        /// <param name="aliveItems"></param>

        /// <param name="TakeCount"></param>

        /// <returns></returns>

        public int SetCleanUpItems(List<string> ProjectList)

        {

            int result = 0;

            var items = entities.CONVERTER_DOC.Where(

                        x =>

                        ProjectList.Contains(x.PROJECT_NO) &&

                        x.STATUS > (int)StatusCodeType.None && x.STATUS < (int)StatusCodeType.Completed

                        || (x.STATUS > (int)StatusCodeType.Error || x.STATUS > (int)StatusCodeType.FileError) && x.RECONVERTER < 2);

            result = items.Count();

            if (items.Count() > 0)

            {

                foreach (var item in items)

                {

                    item.RECONVERTER = item.RECONVERTER + 1;

                    item.CREATE_DATETIME = DateTime.Now;

                    item.START_DATETIME = null;

                    item.END_DATETIME = null;

                    item.STATUS = (int)StatusCodeType.None;

                }

                entities.SaveChanges();

            }

            return result;

        }

        /// <summary>

        /// 전체 컨버터를 가져온다. 비동기로 변경하여야 한다.

        /// </summary>

        /// <returns></returns>

        public List<Interface.ConvertItem> GetConvertItems( StatusCodeType statusCodeType)

        {

            List<Interface.ConvertItem> convertItems = new List<Interface.ConvertItem>();

            var items = entities.CONVERTER_DOC.Where(x=>x.STATUS == (int)statusCodeType).ToList(); //.Where(x => x.PROJECT_NO == gProjectNo);

            if (items.Count() > 0)

            {

                foreach (var item in items)

                {

                    var convertitem = new Interface.ConvertItem(item.DOCUMENT_ID, item.PROJECT_NO, item.ID, item.DOCUMENT_URL);

                    convertitem.ConvertState = ((StatusCodeType)item.STATUS).ToString();

                    convertitem.CreateTime = item.CREATE_DATETIME;

                    convertitem.TotalPage = item.TOTAL_PAGE;

                    convertitem.CurrentPageNo = item.CURRENT_PAGE;

                    convertitem.ConvertPath = GetConvertPath(item.PROJECT_NO, item.DOCUMENT_ID);

                    convertItems.Add(convertitem);

                }

            }

            return convertItems;

        }

        public bool SetConvertState(string UniqueID,int State,int CurrentPage,int TotalPage,string Error)

        {

            bool result = false;

            try

            {

                var items = entities.CONVERTER_DOC.SingleOrDefault(f => f.ID == UniqueID);

                //var items = entities.CONVERTER_DOC.SingleOrDefault(f => f.PROJECT_NO == gProjectNo && f.ID == UniqueID);

                if (items != null)

                {

                    items.STATUS = State;

                    items.CURRENT_PAGE = CurrentPage;

                    items.TOTAL_PAGE = TotalPage;

                    StatusCodeType statusCode = (StatusCodeType)State;

                    switch (statusCode)

                    {

                        case StatusCodeType.None:

                            break;

                        case StatusCodeType.Wait:

                            items.START_DATETIME = DateTime.Now;

                            break;

                        case StatusCodeType.PageLoading:

                            break;

                        case StatusCodeType.Saving:

                            break;

                        case StatusCodeType.Completed:

                            items.END_DATETIME= DateTime.Now;

                            break;

                        case StatusCodeType.FileError:

                            Error = $" file Error :" + Error;

                            items.END_DATETIME = DateTime.Now;

                            break;

                        case StatusCodeType.PageError:

                            Error = $" Page No {CurrentPage} Error :" + Error;

                            break;

                        case StatusCodeType.NeedsPassword:

                            break;

                        case StatusCodeType.Error:

                            Error = $" Error :" + Error;

                            items.END_DATETIME = DateTime.Now;

                            break;

                        default:

                            break;

                    }

                    if(items.EXCEPTION == null)

                    {

                        items.EXCEPTION = "";

                    }

                    if (items.EXCEPTION.Length < 255)

                    {

                        items.EXCEPTION = items.EXCEPTION + Error;

                    }

                    entities.SaveChanges();

                    result = true;

                }

            }

            catch (Exception ex)

            {

                throw new Exception("SetConvertState",ex);

            }

            return result;

        }

        private string BaseStorage(string ProjectNo)

        {

            string result = "";

            var properties = entities.PROPERTIES.Where(f => f.PROPERTY == ProjectNo && f.TYPE == PROPERTIES_DEFINE.TILE_SOURCE_STORAGE);

            if(properties.Count() > 0)

            {

                result = properties.First().VALUE;

            }

            else

            {

                throw new Exception($"Project {ProjectNo} BaseStorage Not Setting.");

            }

            return result;

        }

    }

}