MARKUS

using GemBox.Spreadsheet;

using Markus.Message;

using Markus.Service.DataBase;

using Markus.Service.Extensions;

using Markus.Service.StationController.Behaviors;

using Markus.Service.StationController.Extensions;

using Microsoft.Win32;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Windows;

using Telerik.Windows.Controls;

using Telerik.Windows.Data;

using ConvertItem = Markus.Service.Interface.ConvertItem;

namespace Markus.Service.StationController.ViewModel

{

    //세미

    public class DataBaseItemsModel : Mvvm.ToolKit.ViewModelBase

    {

        BackgroundWorker backgroundWorker;

        Random rnd = new Random();

        private System.Collections.ObjectModel.ObservableCollection<ConvertItem> _FilterConvertSource;

        private ConvertItem _SelectRealConvert;

        private ConvertItem _SelectFilterConvert;

        private StatusTypeList _StatusType;

        private bool _IsLoading;

        private Telerik.Windows.Data.EnumMemberViewModel _SelectedStatus;

        public Telerik.Windows.Data.EnumMemberViewModel SelectedStatus

        {

            get => _SelectedStatus;

            set

            {

                _SelectedStatus = value;

                OnPropertyChanged(() => SelectedStatus);

            }

        }

        private SelectedCountItem _SelectedCount;

        public SelectedCountItem SelectedCount

        {

            get => _SelectedCount;

            set

            {

                _SelectedCount = value;

                OnPropertyChanged(() => SelectedCount);

            }

        }

        public DelegateCommand ConvertCommand { get; private set; }

        public DelegateCommand DeleteCommand { get; private set; }

        private void DataConvert(object obj)

        {

            ConvertDatabase _DataConvert = new ConvertDatabase(App.MarkusDataBaseConnecitonString);

            var resultRealConvert = _DataConvert.SetCleanUpItem(SelectRealConvert.ConvertID, SelectRealConvert.ReConverter);

            var resultFiltertConvert = _DataConvert.SetCleanUpItem(SelectFilterConvert.ConvertID, SelectFilterConvert.ReConverter);

            System.Diagnostics.Debug.WriteLine(resultRealConvert + "  " + resultFiltertConvert);

        }

        private void DataDelete(object obj)

        {

            ConvertDatabase _DataConvert = new ConvertDatabase(App.MarkusDataBaseConnecitonString);

            var resultRealConvert = _DataConvert.RemoveItem(SelectRealConvert.ConvertID);

            var resultFiltertConvert = _DataConvert.RemoveItem(SelectFilterConvert.ConvertID);

            System.Diagnostics.Debug.WriteLine(resultRealConvert + "  " + resultFiltertConvert);

        }

        public System.Collections.ObjectModel.ObservableCollection<ConvertItem> FilterConvertSource

        {

            get => _FilterConvertSource;

            set

            {

                _FilterConvertSource = value;

                OnPropertyChanged(() => FilterConvertSource);

            }

        }

        private System.Collections.ObjectModel.ObservableCollection<ConvertItem> _RealConvertSource;

        public System.Collections.ObjectModel.ObservableCollection<ConvertItem> RealConvertSource

        {

            get => _RealConvertSource;

            set

            {

                _RealConvertSource = value;

                OnPropertyChanged(() => RealConvertSource);

            }

        }

        public ConvertItem SelectFilterConvert

        {

            get => _SelectFilterConvert;

            set

            {

                _SelectFilterConvert = value;

                OnPropertyChanged(() => SelectFilterConvert);

            }

        }

        public ConvertItem SelectRealConvert

        {

            get => _SelectRealConvert;

            set

            {

                _SelectRealConvert = value;

                OnPropertyChanged(() => SelectRealConvert);

            }

        }

        public StatusTypeList StatusType

        {

            get => _StatusType;

            set

            {

                _StatusType = value;

                OnPropertyChanged(() => StatusType);

            }

        }

        public bool IsLoading

        {

            get => _IsLoading;

            set

            {

                if (_IsLoading != value)

                {

                    _IsLoading = value;

                    OnPropertyChanged(() => IsLoading);

                }

            }

        }

        List<SelectedCountItem> _SelectedCountList;

        public List<SelectedCountItem> SelectedCountList

        {

            get

            {

                if (_SelectedCountList == null)

                {

                    _SelectedCountList = new List<SelectedCountItem>

                    {

                        new SelectedCountItem{DisplayMember = "50",ValueMember = 50},

                        new SelectedCountItem{DisplayMember = "100",ValueMember = 100},

                        new SelectedCountItem{DisplayMember = "150",ValueMember = 150},

                        new SelectedCountItem{DisplayMember = "200",ValueMember = 200}

                    };

                }

                return _SelectedCountList;

            }

        }

        public DataBaseItemsModel()

        {

            DataSaveFileGemBoxCommand = new DelegateCommand(DataExport);

            ConvertCommand = new DelegateCommand(DataConvert);

            DeleteCommand = new DelegateCommand(DataDelete);

            //Loaded();

        }

        // 진행률에 변화가 있을때 이벤트가 발생

        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)

        {

            MessageBox.Show("진행률에 변화");

        }

        // 일이 모두 마쳤을때 수행되어야할 코드

        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

        {

            MessageBox.Show("임무마침");

        }

        IEnumerable<Telerik.Windows.Data.EnumMemberViewModel> _StatusCodeList;

        public IEnumerable<Telerik.Windows.Data.EnumMemberViewModel> StatusCodeList

        {

            get

            {

                if (_StatusCodeList == null)

                {

                    _StatusCodeList = Telerik.Windows.Data.EnumDataSource.FromType<StatusCodeType>();

                }

                return _StatusCodeList;

            }

        }

        // BackgroundWorker에서 수행할 일을 정의.

        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

            while (IsAcitve)

            {

                if (FilterConvertSource == null)

                {

                    FilterConvertSource = new System.Collections.ObjectModel.ObservableCollection<ConvertItem>();

                }

                if (RealConvertSource == null)

                {

                    RealConvertSource = new System.Collections.ObjectModel.ObservableCollection<ConvertItem>();

                }

                /// combobox 에서 선택된 items

                if (SelectedStatus != null)

                {

                    DataSelect(new[] { (StatusCodeType)(SelectedStatus.Value) }, FilterConvertSource);

                }

                /// 컨버터중인 items

                DataSelect(new[] { StatusCodeType.None, StatusCodeType.Wait, StatusCodeType.PageLoading, StatusCodeType.Saving }, RealConvertSource);

            }

        }

        //<>쓸때는 IEnumerable 

        private void DataSelect(IEnumerable<StatusCodeType> statusCodeTypeList, System.Collections.ObjectModel.ObservableCollection<ConvertItem> collection)

        {

            try

            {

                using (Markus.Service.DataBase.ConvertDatabase database = new Markus.Service.DataBase.ConvertDatabase(App.MarkusDataBaseConnecitonString))

                {

                    var items = database.GetConvertProjects(x => statusCodeTypeList.Count(y => (int)y == x.STATUS) > 0)

                                                .OrderByDescending(x => x.CreateTime).Take(SelectedCount.ValueMember).ToList();

                    if (collection.Count() == 0)

                    {

                        items.ForEach(x => collection.Add(x));

                    }

                    else

                    {

                        // 데이터 업데이트

                        items.ForEach(newitem =>//디비 포문

                        {

                            collection.UpdateWhere(changeitem =>

                            {

                                ConvertItemEx.ChangeValues(changeitem, newitem);

                                System.Threading.Thread.Sleep(new TimeSpan(0, 0, 0, 0, 10));

                            }, x => x.ConvertID == newitem.ConvertID);//UpdateWhere의  where절

                        });

                        foreach (var item in items)

                        {

                            //  System.Threading.Thread.Sleep(1);

                            if (collection.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                            {

                                collection.Add(item);

                            }

                        }

                        //삭제

                        for (int i = collection.Count() - 1; i > -1; --i)

                        {

                            var item = collection[i];

                            if (items.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)//디비에서 가져온 값과 마지막값부터 차례대로 비교

                            {//참=> 0제외한 모든 수

                                collection.RemoveAt(i);

                            }

                            // System.Threading.Thread.Sleep(new TimeSpan(0, 0, 0, 0, 1));

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.ToString());

            }

        }

        public override void Loaded()

        {

            base.Loaded();

            if (!App.IsDesignMode)

            {

                backgroundWorker = new BackgroundWorker();

                backgroundWorker.DoWork += backgroundWorker_DoWork;

                backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;

                backgroundWorker.WorkerReportsProgress = false;

                backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);

                backgroundWorker.RunWorkerAsync();

            }

        }

        public override void Closed()

        {

            if (backgroundWorker != null)

            {

                backgroundWorker.DoWork -= backgroundWorker_DoWork;

                backgroundWorker.RunWorkerCompleted -= backgroundWorker_RunWorkerCompleted;

                backgroundWorker.WorkerReportsProgress = false;

                backgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);

            }

            base.Closed();

        }

        public DelegateCommand DataSaveFileGemBoxCommand { get; private set; }

        public class HeaderMember

        {

            public string HeaderName { get; set; }

            public string Property { get; set; }

        }

        //public void DataExport<T>(IEnumerable<T> AliveItems)

        public void DataExport(object obj)

        {

            SaveFileDialog saveFileDialog = new SaveFileDialog();

            saveFileDialog.FileName = "Document"; // Default file name

            saveFileDialog.DefaultExt = ".txt"; // Default file extension

            saveFileDialog.Filter = "Csv documents (.Csv)|*.csv|Excel(2017~2019)Worksheets|*.xlsx"; // Filter files by extension

            if (saveFileDialog.ShowDialog() == true)

            {

                if (!string.IsNullOrWhiteSpace(saveFileDialog.FileName))

                {

                    var extension = new System.IO.FileInfo(saveFileDialog.FileName).Extension;

                    if (extension == ".xlsx" || extension == ".csv")

                    {

                        var headers = new List<HeaderMember>

                        {

                            new HeaderMember{HeaderName = "ServiceID", Property = "ServiceID" },

                            new HeaderMember{HeaderName = "ConvertID", Property = "ConvertID" },

                            new HeaderMember{HeaderName = "ProjectNumber", Property = "ProjectNumber" },

                            new HeaderMember{HeaderName = "ConvertState", Property = "ConvertState" },

                            new HeaderMember{HeaderName = "CurrentPageNo", Property = "CurrentPageNo" },

                            new HeaderMember{HeaderName = "TotalPage", Property = "TotalPage" },

                            new HeaderMember{HeaderName = "OriginfilePath", Property = "OriginfilePath" },

                            new HeaderMember{HeaderName = "ConvertPath", Property = "ConvertPath" },

                            new HeaderMember{HeaderName = "CreateTime", Property = "CreateTime" },

                            new HeaderMember{HeaderName = "Exception", Property = "Exception" },

                            new HeaderMember{HeaderName = "ProcessorAffinity", Property = "ProcessorAffinity" },

                            new HeaderMember{HeaderName = "ReConverter", Property = "ReConverter" },

                            new HeaderMember{HeaderName = "UniqueKey", Property = "UniqueKey" }

                        };

                        DataExportExcel(saveFileDialog.FileName, "Hello world", FilterConvertSource, headers);

                        //_dataExport.DataExportExcel(saveFileDialog.FileName, saveFileDialog.FileName.ToString(),  Projectsource, headers);

                        //GemBoxFileSave(obj);

                    }

                }

            }

        }

        public void DataExportExcel<T>(string SaveFile, string SheetName, IEnumerable<T> collections, List<HeaderMember> headerMembers)

        {

            try

            {

                SpreadsheetInfo.SetLicense("EXK0-W4HZ-N518-IMEW");

                // SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY");//프리버전은 15줄까지만 가능

                var workbook = new ExcelFile();

                var worksheet = workbook.Worksheets.Add(SheetName);

                // IEnumerable<T> collections를 for문

                for (int rowNumber = 0; rowNumber < collections.Count(); rowNumber++)//1857  양이 너무 많아서 빨리 엑셀출력 누르면 숫자가 감소됨 차분히 기다리면 숫자 늘어남

                {

                    // index에 해당하는 row를 가져온다.

                    object row = collections.ElementAt(rowNumber);//우왕좌왕하게 모든 프로퍼티 있음 생성자 프로퍼티도 있음

                    //row의 properties를 가져옴.

                    var rowPropInfos = row.GetType().GetProperties();//행렬로 보기좋게 프로퍼티 나옴

                    /// 지정된 header에 대해서 프로퍼티에 해당하는 값을 가져와서 cell에 출력

                    for (int i = 0; i < headerMembers.Count(); i++)//13

                    {

                        var prop = rowPropInfos.Where(x => x.Name == headerMembers[i].Property);//prop 0으로 나옴

                        if (headerMembers[i].Property == "CreateTime")

                        {

                            worksheet.Cells[rowNumber + 1, i].Value = prop.First().GetValue(row).ToString();

                        }

                        else if (prop.Count() > 0)

                        {

                            worksheet.Cells[rowNumber + 1, i].Value = prop.First().GetValue(row);

                        }

                    }

                }

                int k = 0;

                foreach (var HeadInfo in headerMembers)

                {

                    worksheet.Cells[0, k].Value = HeadInfo.HeaderName;

                    k++;

                }

                int columnCount = worksheet.CalculateMaxUsedColumns();

                for (int i = 0; i < columnCount; i++)

                {

                    worksheet.Columns[i].AutoFit();

                }

                var header = new CellStyle();//헤더

                header.FillPattern.SetSolid(SpreadsheetColor.FromArgb(0, 100, 220));

                header.Font.Weight = ExcelFont.BoldWeight;

                header.HorizontalAlignment = HorizontalAlignmentStyle.Center;

                header.VerticalAlignment = VerticalAlignmentStyle.Center;

                //worksheet.Cells.GetSubrange("A1:M1").Style = header;

                worksheet.Cells.GetSubrangeAbsolute(0, 0, collections.Count(), headerMembers.Count() - 1).Style = header;

                var style = new CellStyle();

                //style.Borders.SetBorders(MultipleBorders.Right | MultipleBorders.Top | MultipleBorders.Left | MultipleBorders.Bottom, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thick);//바깥쪽 border 두껍게 성공

                style.Borders.SetBorders(MultipleBorders.Outside, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thick);//바깥쪽 border 두껍게 성공

                style.HorizontalAlignment = HorizontalAlignmentStyle.Center;

                style.VerticalAlignment = VerticalAlignmentStyle.Center;

                style.Font.Color = SpreadsheetColor.FromArgb(75, 60, 50);//글자 색갈

                style.FillPattern.SetSolid(SpreadsheetColor.FromArgb(126, 239, 239));//cell 색갈

                style.Font.Name = "맑은 고딕";

                style.Font.Size = 9 * 20;

                worksheet.Cells.GetSubrangeAbsolute(0, 0, collections.Count(), headerMembers.Count() - 1).Style = style;

                //worksheet.Cells.GetSubrange("A1:M1858").Style = style;

                for (int line = 0; line < collections.Count() - 1; line++) //바깥border과 안쪽 얇은 border 같이 쓰면 안됨

                {

                    //for (int j = 0; j < 14 - 1 - 1; j++)

                    for (int j = 0; j < headerMembers.Count() - 1 - 1; j++)

                    {

                        worksheet.Cells[line + 1, j + 1].Style.Borders.SetBorders(MultipleBorders.Outside, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//안쪽 (1,1) ~ (마지막-1,마지막-1) 가운데 성공

                    }

                }

                for (int line = 0; line < collections.Count(); line++) //바깥border과 안쪽 얇은 border 같이 쓰면 안됨

                {//Projectsource.Count() = 761개 ( 0 ~ 760 )

                    for (int j = 0; j < headerMembers.Count() - 1; j++)

                    {

                        worksheet.Cells[0, j].Style.Borders.SetBorders(MultipleBorders.Right, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(0,0) ~ (0,마지막-1) 위 성공

                        worksheet.Cells[collections.Count(), j].Style.Borders.SetBorders(MultipleBorders.Right, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(마지막,0) ~ (마지막,마지막-1) 아래 성공

                    }

                    worksheet.Cells[line, 0].Style.Borders.SetBorders(MultipleBorders.Bottom, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(0,0) ~ (마지막-1,0) 왼쪽 성공

                    worksheet.Cells[line, headerMembers.Count() - 1].Style.Borders.SetBorders(MultipleBorders.Bottom, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(0,마지막) ~ (마지막-1,마지막) 오른쪽 성공

                }

                workbook.Save(SaveFile);//파일 열었던 파일로 저장 성공

                MessageBox.Show("성공");

            }

            catch (Exception ex)

            {

                Console.WriteLine("예외 발생!! 메세지: {0}", ex.Message);

            }

        }

    }

    public class SelectedCountItem

    {

        public string DisplayMember { get; set; }

        public int ValueMember { get; set; }

    }

}