MARKUS

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace KCOM.PageManager

{

    public class PageStorage

    {

        public event EventHandler<PageLoadCompletedEventArgs> PageLoadCompleted;

        private const int DEFUALT_TALK_PAGE_COUNT = 10;

        List<int> WorkItems = new List<int>();

        ConcurrentBag<PageItem> fileItems = new ConcurrentBag<PageItem>();

        BackgroundWorker backgroundWorker;

        string _localStorage;

        string _fileExt;

        string _BaseUri;

        int _TotalPages;

        int _TakeCount;

        bool IsWork = false;

        bool IsDownload = false;

        public PageStorage(string BaseUri, string localStoragePath, string fileExt, int totalPages, int takeCount = 5)

        {

            try

            {

                backgroundWorker = new BackgroundWorker { WorkerSupportsCancellation = true, WorkerReportsProgress = true };

                backgroundWorker.DoWork += BackgroundWorker_DoWork;

                backgroundWorker.ProgressChanged += BackgroundWorker_ProgressChanged;

                _fileExt = fileExt;

                _BaseUri = BaseUri;

                _localStorage = localStoragePath;

                _TotalPages = totalPages;

                _TakeCount = takeCount;

                System.IO.Directory.CreateDirectory(_localStorage);

                //backgroundWorker.RunWorkerAsync(new int[] { 1, 10 });

            }

            catch (Exception ex)

            {

                throw new Exception("PageStorage", ex);

            }

        }

        private void BackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)

        {

            System.Diagnostics.Debug.WriteLine(_fileExt + ":" + e.ProgressPercentage.ToString() + "%");

        }

        private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

             DownloadWork();

        }

        private void DownloadWork()

        { 

            while (WorkItems.Count > 0)

            {

                if (!IsDownload)

                {

                    int item = -1;

                    try

                    {

                        if (WorkItems.TryFrist(true, out item))

                        {

                            var result = DownloadPageAsync(item, null);

                        }

                    }

                    catch (Exception ex)

                    {

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

                    }

                }

                System.Threading.Thread.Sleep(100);

            }

            IsWork = false;

        }

        public async void DownloadWorkAsync(int startPage, int TakeCount)

        {

            if (0 < _TakeCount && startPage < _TotalPages)

            {

                int takecount = _TakeCount;

                if (_TotalPages < startPage + takecount)

                {

                    takecount = _TotalPages - startPage;

                    _TakeCount = 0;

                }

                WorkItems.AddRange(Enumerable.Range(startPage, TakeCount - 1));

            }

            if (!IsWork && WorkItems.Count() > 0)

            {

                IsWork = true;

                await Task.Run(() => DownloadWork());

            }

            //if (!backgroundWorker.IsBusy && WorkItems.Count() > 0)

            //{

            //    backgroundWorker.RunWorkerAsync();

            //}

        }

        public  void DownloadWork(int startPage, int TakeCount)

        {

            if (0 < _TakeCount && startPage <= _TotalPages)

            {

                WorkItems.AddRange(Enumerable.Range(startPage, _TotalPages));

            }

            if (!IsWork && WorkItems.Count() > 0)

            {

                IsWork = true;

                DownloadWork();

            }

        }

        public async Task<Uri> GetPageUriAsync(System.Threading.CancellationToken? cts, int PageNo, bool IsRestart = false)

        {

            IsDownload = true;

            Uri result = null;

            try

            {

                System.Diagnostics.Debug.WriteLine("GetPageAsync");

                var pageItem = await DownloadPageAsync(PageNo, cts);

                // 다음 페이지가 미리 다운로드 되도록 추가

                if (pageItem != null && 0 < _TakeCount && PageNo + 1 < _TotalPages)

                {

                    int takecount = _TakeCount;

                    if (_TotalPages < PageNo + 1 + takecount)

                    {

                        takecount = _TotalPages - PageNo + 1;

                    }

                    DownloadWorkAsync(PageNo + 1, takecount);

                    //var takePageNoList = Enumerable.Range(PageNo + 1, _TakeCount);

                }

                result = pageItem.LocalUri;

            }

            catch (Exception ex)

            {

                if (cts != null)

                {

                    if (cts.Value.IsCancellationRequested)

                    {

                        return result;

                    }

                }

                if (!IsRestart)

                {

                    await Task.Delay(100);

                    result = await GetPageUriAsync(cts, PageNo, true);

                }

                //throw new Exception("GetPageAsync(string BasePageUri,int PageNo)", ex);

            }

            finally

            {

                IsDownload = false;

            }

            return result;

        }

        public async Task<PageItem> DownloadPageAsync(int PageNo, System.Threading.CancellationToken? cts)

        {

            IsDownload = true;

            PageItem result = new PageItem { PageNo = PageNo };

            try

            {

                var page = fileItems.Where(x => x.PageNo == PageNo).ToList();

                if (page.Count > 0)

                {

                    System.Diagnostics.Debug.WriteLine("DownloadPageAsync fileItems");

                    result = page.First();

                    /// 파일 체크 후 없으면 다시 다운로드

                    if (!System.IO.File.Exists(result.LocalFilePath))

                    {

                        //fileItems.(result);

                        result = await DownloadPageAsync(PageNo, cts);

                    }

                }

                else

                {

                    System.Diagnostics.Debug.WriteLine("DownloadPageAsync down");

                    string downloadFilePath = System.IO.Path.Combine(_localStorage, PageNo.ToString() + "." + _fileExt);

                    Uri originalUri = new Uri(_BaseUri.Replace("{PageNo}", PageNo.ToString()));

                    result = new PageItem

                    {

                        PageNo = PageNo,

                        OriginalUri = originalUri,

                        LocalUri = new Uri(downloadFilePath, UriKind.Absolute),

                        LocalFilePath = downloadFilePath

                    };

                    if (fileItems.Where(x => x.PageNo == PageNo).Count() == 0)

                    {

                        fileItems.Add(result);

                    }

                    using (System.Net.WebClient client = new System.Net.WebClient())

                    {

                        client.UseDefaultCredentials = true;

                        //client.Headers.Add("user-agent", "Your User-Agent");

                        System.Net.IWebProxy webProxy = client.Proxy;

                        if (webProxy != null)

                        {

                            // Use the default credentials of the logged on user.

                            webProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;

                        }

                        if (cts != null)

                        {

                            client.DownloadProgressChanged += (snd, ect) =>

                            {

                                IsDownload = client.IsBusy;

                                if (cts.Value.IsCancellationRequested)

                                {

                                    client.CancelAsync();

                                }

                            };

                        }

                        client.DownloadFileCompleted += (snd, evt) =>

                        {

                            result.IsDownLoad = true;

                            bool isLast = false;

                            if(result.PageNo == _TotalPages)

                            {

                                isLast = true;

                            }

                            PageLoadCompleted?.Invoke(this, new PageLoadCompletedEventArgs(result, isLast));

                            System.Diagnostics.Debug.WriteLine("Download : " + downloadFilePath);

                        };

                        await client.DownloadFileTaskAsync(originalUri, downloadFilePath);

                    }

                    //}

                    //System.Diagnostics.Debug.WriteLine("Download : " + result.LocalFilePath);

                }

            }

            catch (Exception ex)

            {

                throw new Exception("DownloadPageAsync : ", ex);

            }

            finally

            {

                IsDownload = false;

            }

            return result;

        }

        public void Clear()

        {

            try

            {

                backgroundWorker.CancelAsync();

                backgroundWorker.Dispose();

                foreach (var item in fileItems)

                {

                    System.IO.File.Delete(item.LocalFilePath);

                }

                System.IO.Directory.Delete(_localStorage, true);

            }

            catch (Exception ex)

            {

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

            }

        }

    }

}