MARKUS

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Net;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Media.Imaging;

namespace KCOM.PageManager

{

    public class PageStorage

    {

        private const int DEFUALT_TALK_PAGE_COUNT = 10;

        public event EventHandler<PageLoadCompletedEventArgs> PageLoadCompleted;

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

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

        BackgroundWorker backgroundWorker;

        //List<PageItem> fileItems = new List<PageItem>();

        public string LocalStorage;

        string _fileExt;

        string _BaseUri;

        int _TotalPages;

        int _TakeCount;

        string _token;

        bool IsBusy = false;

        BitmapFrame PageImage;

        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;

                //_token = Authenticate();

                System.IO.DirectoryInfo info = 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 async void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

            while (WorkItems.Count > 0)

            {

                if (backgroundWorker.CancellationPending)

                {

                    e.Cancel = true;

                    return;

                }

                if (!IsBusy)

                {

                    int item = -1;

                    try

                    {

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

                        { 

                            var result = await DownloadPageAsync(item, null);

                            if (!result.IsDownLoad)

                            {

                                System.Threading.Thread.Sleep(100);

                            }

                            await Task.Delay(100);

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

                            //backgroundWorker.ReportProgress(fileItems.Count / _TotalPages * 100);

                        }

                    }

                    catch (Exception ex)

                    {

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

                    }

                }

            }

        }

        public void ResetImage()

        {

            //if (PageImage != null)

            //{

            //    PageImage = null;

            //}

            //PageImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;

        }

        public async Task<BitmapFrame> GetPageImageAsync(System.Threading.CancellationToken cts, int PageNo, bool IsRestart = false)

        {

            try

            {

                var localUri = await GetPageUriAsync(cts, PageNo);

                if (localUri != null) // || !cts.IsCancellationRequested

                {

                    PageImage = BitmapFrame.Create(localUri, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);

                }

            }

            catch (Exception ex)

            {

                PageImage = BitmapFrame.Create(new Uri(_BaseUri.Replace("{PageNo}", PageNo.ToString())), BitmapCreateOptions.None, BitmapCacheOption.OnLoad);

            }

            finally

            {

            }

            return PageImage;

        }

        private void DownloadWorkAsync(int startPage, int TakeCount)

        {

            lock (WorkItems)

            {

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

            }

            if (TakeCount == _TotalPages)

            {

                _TakeCount = 0;

            }

            // var files = fileItems.Select(x => x.PageNo);

            //for (int i = startPage; i < TakeCount + 1; i++)

            //{

            //    if (i < _TotalPages && !WorkItems.Contains(i) && !files.Contains(i))

            //    {

            //        WorkItems.Add(i);

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

            //    }

            //    else if(i == _TotalPages)

            //    {

            //        _TakeCount = 0;

            //    }

            //}

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

            {

                backgroundWorker.RunWorkerAsync();

            }

            //await Task.Delay(10);//  System.Threading.Thread.Sleep(10);

            //while (WorkItems.Count > 0)

            //{

            //    int item = -1;

            //    if (WorkItems.TryDequeue(out item))

            //    {

            //        var result = await DownloadPageAsync(item, null);

            //    }

            //}

        }

        /// <summary>

        /// 

        /// </summary>

        /// <param name="cts"></param>

        /// <param name="PageNo"></param>

        /// <param name="IsClone"></param>

        /// <param name="IsRestart"></param>

        /// <returns></returns>

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

        {

            Uri result = null;

            try

            {

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

                var pageItem = await DownloadPageAsync(PageNo, cts);

                if (pageItem != null)

                {

                    result = pageItem.LocalUri;

                    //if(PageNo + _TakeCount < _TotalPages)

                    //{

                    //    int takecount = 5;

                    //    if (_TotalPages < PageNo + takecount)

                    //    {

                    //        takecount = takecount - (PageNo + takecount - _TotalPages) - 1;

                    //    }

                    //    DownloadWorkAsync(PageNo + 1, takecount);

                    //}

                    //int takecount = _TakeCount;

                    //if (_TotalPages < PageNo + takecount)

                    //{

                    //    takecount = takecount - (PageNo + takecount - _TotalPages) - 1;

                    //}

                    //DownloadWorkAsync(PageNo + 1, takecount);

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

                }

                else

                {

                }

            }

            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

            {

            }

            return result;

        }

        public string Authenticate()

        {

            string result = null;

            try

            {

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

                {

                    client.Headers.Add(HttpRequestHeader.Authorization, "!dsfadsfa@@~");

                    var response = client.DownloadString(App.BaseAddress + "/Authenticate");

                    if (response != null)

                    {

                        result = response;

                    }

                }

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return result;

        }

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

        {

            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

                {

                    if (!System.IO.Directory.Exists(LocalStorage))

                    {

                        System.IO.Directory.CreateDirectory(LocalStorage);

                        System.Threading.Thread.Sleep(50);

                    }

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

                    string downloadFilePath = System.IO.Path.Combine(LocalStorage, System.IO.Path.GetRandomFileName()); /// 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

                    };

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

                    System.Diagnostics.Debug.WriteLine("download start " + downloadFilePath);

                    client.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.NoCacheNoStore);

                    client.Headers.Add("Cache-Control", "no-cache");

                    //client.Headers.Add(HttpRequestHeader.Authorization, _token);

                    //client.ResponseHeaders.Add(HttpRequestHeader.Authorization,)

                    client.UseDefaultCredentials = true;

                    System.Net.IWebProxy webProxy = client.Proxy;

                    if (webProxy != null)

                    {

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

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

                    }

                    AsyncCompletedEventHandler downloadFileCompleteHandler = (snd, evt) =>

                    {

                        if (!evt.Cancelled)

                        {

                            result.IsDownLoad = true;

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

                            {

                                fileItems.Add(result);

                            }

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

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

                        }

                        else

                        {

                            //client.DownloadFileCompleted -= downloadFileCompleteHandler;

                            //client.DownloadProgressChanged -= downloadProgressHandler;

                            client.Dispose();

                            client = null;

                            System.IO.File.Delete(downloadFilePath);

                            Console.WriteLine("Request cancelled!");

                            result = null;

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

                        }

#if !DOWNLOAD_TEST

                        KCOM.Common.ViewerDataModel.Instance.PagImageCancelDispose();

#endif

                    };

                    if (cts != null)

                    {

                        DownloadProgressChangedEventHandler downloadProgressHandler = (snd, ect) =>

                        {

                              IsBusy = client.IsBusy;

                        };

                        cts.Value.Register(() =>

                        {

                            client.CancelAsync();

                        });

                        client.DownloadProgressChanged += downloadProgressHandler;

                    }

                    client.DownloadFileCompleted += downloadFileCompleteHandler;

                    await client.DownloadFileTaskAsync(originalUri, downloadFilePath); 

                }

            }

            catch (WebException ex) when (ex.Status == WebExceptionStatus.RequestCanceled)

            {

                Console.WriteLine("Cancelled");

            }

            catch (Exception ex)

            {

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

            }

            finally

            {

                IsBusy = false;

            }

            return result;

        }

        private void downloadFileCompleteHandler(object sender, AsyncCompletedEventArgs e)

        {

            throw new NotImplementedException();

        }

        public void Clear()

        {

            try

            {

                ResetImage();

            }

            catch (Exception ex)

            {

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

            }

            try

            {

                backgroundWorker.CancelAsync();

                backgroundWorker.Dispose();

                /// downloadmanager에서 삭제함

                //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());

            }

        }

    }

}