MARKUS

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

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;

        BackgroundWorker backgroundWorker;

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

        string _localStorage;

        string _BaseUri;

        int _TotalPages;

        BitmapFrame PageImage;

        public PageStorage(string BaseUri, string localStoragePath,int totalPages)

        {

            try

            {

                backgroundWorker = new BackgroundWorker {WorkerSupportsCancellation = true };

                backgroundWorker.DoWork += BackgroundWorker_DoWork;

                _BaseUri = BaseUri;

                _localStorage = localStoragePath;

                _TotalPages = totalPages;

                System.IO.Directory.CreateDirectory(_localStorage);

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

            }

            catch (Exception ex)

            {

                throw new Exception("PageStorage", ex);

            }

        }

        private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

            int StartPageNo = -1;

            int TalkCount = -1;

            if (e.Argument != null)

            {

                var values = (e.Argument as int[]);

                if (values.Count() == 2)

                {

                    StartPageNo = values[0];

                    TalkCount = values[1];

                    DownloadPagesAsync(StartPageNo, TalkCount);

                }

            }

        }

        public void ResetImage()

        {

            //if (PageImage != null)

            //{

            //    PageImage = null;

            //}

            //PageImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;

        }

        public async Task<BitmapFrame> GetPageAsync(int PageNo)

        {

            try

            {

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

                while (backgroundWorker.IsBusy)

                {

                    await Task.Delay(100);

                    if (backgroundWorker.IsBusy)

                    {

                        backgroundWorker.CancelAsync();

                    }

                }

                var pageItem = await DownloadPageAsync(PageNo);

                backgroundWorker.RunWorkerAsync(new int[] { PageNo + 1, 5 });

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

            }

            catch (Exception)

            {

                PageImage = await GetPageAsync(PageNo);

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

            }

            finally

            {

            }

            return PageImage;

        }

        public void DownloadPagesAsync(int StartPageNo, int TalkCount = 5)

        {

            try

            {

                if (StartPageNo + TalkCount > _TotalPages)

                {

                    TalkCount = _TotalPages - StartPageNo;

                }

                if (TalkCount > 0)

                {

                    for (int i = StartPageNo; i < StartPageNo + TalkCount; i++)

                    {

                        try

                        {

                            DownloadPageAsync(i).RunAndForget();

                        }

                        catch (Exception ex)

                        {

                            System.Diagnostics.Debug.WriteLine("DownloadPagesAsync err", ex);

                        }

                        finally

                        {

                        }

                    }

                }

            }

            catch (Exception ex)

            {

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

            }

            finally

            {

            }

        }

        public async Task<PageItem> DownloadPageAsync(int PageNo)

        {

            PageItem result = new PageItem { PageNo = PageNo };

            try

            {

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

                if (page.Count() > 0)

                {

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

                    PageItem item = page.First();

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

                    if (System.IO.File.Exists(item.LocalFilePath))

                    {

                        result = page.First();

                    }

                    else

                    {

                        fileItems.Remove(item);

                        result = await DownloadPageAsync(PageNo);

                    }

                }

                else

                {

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

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

                    result = new PageItem

                    {

                        PageNo = PageNo,

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

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

                        LocalFilePath = downloadFilePath

                    };

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

                    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;

                    }

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

                    {

                        fileItems.Add(result);

                    };

                    await client.DownloadFileTaskAsync(result.OriginalUri, downloadFilePath);

                    GC.Collect();

                    GC.WaitForPendingFinalizers();

                    GC.Collect();

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

                }

            }

            catch (Exception ex)

            {

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

            }

            finally

            {

            }

            return result;

        }

        public void Clear()

        {

            try

            {

                ResetImage();

            }

            catch (Exception ex)

            {

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

            }

            try

            {

                backgroundWorker.CancelAsync();

                backgroundWorker.Dispose();

                fileItems.ForEach(x =>

                {

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

                });

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

            }

            catch (Exception ex)

            {

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

            }

        }

    }

}