source: extensions/PiwigoLib/PiwigoWpf/Services/ImageCacheManager.cs @ 13836

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Com.Piwigo.Wpf.DTO;
using System.Threading;
using System.IO;
using System.Net;
using System.Drawing;
using Com.Piwigo.Wpf.Helper;

namespace Com.Piwigo.Wpf.Service
{
    public class ImageCacheManager
    {
        #region WPF Converter
        static readonly ImageUrlCachedConverter _imageUrlCachedConverter = new ImageUrlCachedConverter();

        public static ImageUrlCachedConverter ImageUrlCachedConverter
        {
            get
            {
                return _imageUrlCachedConverter;
            }
        }

        public static String GetDefaultImage()
        {
            return ("pack://application:,,,/Pictures/64x64/images.png");
        }

        public static String GetLoadImage()
        {
            return ("pack://application:,,,/Pictures/64x64/html.png");
        }

        #endregion WPF Converter

        #region Singleton
        static readonly ImageCacheManagerBase _instance = new ImageCacheManagerBase();

        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static ImageCacheManager()
        {
            Int32 a, b;
            ThreadPool.GetMaxThreads(out a, out b);
            if (a>20) a = 20;
            ThreadPool.SetMaxThreads(a, b);
        }

        public static ImageCacheManagerBase Instance
        {
            get
            {
                return _instance;
            }
        }
        #endregion Singleton

        #region singleton base class
        public class ImageCacheManagerBase : IDisposable
        {
            #region DTO
            // local DTO
            internal class AlbumDictionnaryItem
            {
                internal DirectoryInfo BasePath;
                internal String AlbumId;
            };

            internal class AlbumDictionnary : SortedDictionary<String, AlbumDictionnaryItem> { };

            internal class ServerDictionnaryItem
            {
                internal DirectoryInfo BasePath;
                internal AlbumDictionnary Albums;
                internal Uri ServeurUrl;
            };

            internal class ServerDictionnary : SortedDictionary<String, ServerDictionnaryItem> { };

            internal static DirectoryInfo AppCachedDataDirectory = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),"PiwigoWpf", "cache"));

            internal Object _lock = new Object();
            internal ServerDictionnary _aServerDictionnary;
            internal ServerDictionnaryItem _currentServer;
            internal AlbumDictionnaryItem _currentAlbum;

            #endregion DTO

            #region local helper
            // local helper
            static private String BuildServerDirCache(String serveurUri)
            {
                String ServerDirCache = Path.Combine(AppCachedDataDirectory.FullName, serveurUri.Replace("http://", "_").Replace("/", "_"));
                System.Diagnostics.Debug.Print(ServerDirCache);

                return ServerDirCache;
            }
            
            static private String BuildAlbumDirCache(ServerDictionnaryItem server, String CatgeoryId)
            {
                String AlbumDirCache = String.Empty;
                if (server != null)
                {
                    AlbumDirCache = Path.Combine(server.BasePath.FullName, CatgeoryId.Replace("/", "_")); 
                }
                else
                {
                    throw new ApplicationException ("Current server not set before using Album");
                }

                return AlbumDirCache;
            }

            static private ServerDictionnary BuildServerDictionnaryFromCache()
            {
                ServerDictionnary retLstServerDictionnary = new ServerDictionnary();

                if (AppCachedDataDirectory.Exists)
                {
                    foreach (DirectoryInfo Dir in AppCachedDataDirectory.GetDirectories())
                    {
                        FileInfo xmlData = new FileInfo(Path.Combine(Dir.FullName, "serverdictionnaryitem.xml"));
                        if (xmlData.Exists)
                        {
                            ServerDictionnaryItem item = XMLHelper<ServerDictionnaryItem>.DeserializeObjectFromFile(xmlData);
                            retLstServerDictionnary.Add(item.ServeurUrl.ToString(), item);
                        }
                    }
                }

                return retLstServerDictionnary;
            }

            static void WriteServerDictionnaryToDisk(ServerDictionnary dcServer)
            {
                foreach (ServerDictionnaryItem Item in dcServer.Values)
                {
                    FileInfo xmlData = new FileInfo(Path.Combine(Item.BasePath.FullName, "serverdictionnaryitem.xml"));
                    XMLHelper<ServerDictionnaryItem>.SerializeToXMLFile(Item, xmlData);
                }
            }
            #endregion local helper

            public void UnsetCurrentServer()
            { 
                _currentAlbum = null;
                _currentServer = null;
            }

            public void SetCurrentServer(String serveurUri)
            {
                String currentserverDir = BuildServerDirCache(serveurUri);
                lock (_lock)
                {
                    // load data from disk on first access
                    if (_aServerDictionnary == null)
                    {
                        _aServerDictionnary = BuildServerDictionnaryFromCache();
                    }

                    if (_aServerDictionnary.ContainsKey(serveurUri))
                    {
                        _currentServer = _aServerDictionnary[serveurUri];
                    }
                    else
                    {
                        ServerDictionnaryItem server = new ServerDictionnaryItem();
                        server.ServeurUrl = new Uri(serveurUri);
                        server.BasePath = new DirectoryInfo(currentserverDir);
                        server.Albums = new AlbumDictionnary();
                        _aServerDictionnary.Add(serveurUri, server);
                        _currentServer = server;
                    }

                    if (!Directory.Exists(currentserverDir))
                    {
                        //Create it
                        Directory.CreateDirectory(currentserverDir);
                        _currentServer.Albums.Clear();
                    }
                }
            }

            public void SetCurrentAlbum(String AlbumId)
            {
                if (_currentServer != null)
                {
                    lock (_lock)
                    {
                        String currentsAlbumDir = BuildAlbumDirCache(_currentServer, AlbumId);
                        if (_currentServer.Albums.ContainsKey(AlbumId))
                        {
                            _currentAlbum = _currentServer.Albums[AlbumId];
                        }
                        else
                        {
                            AlbumDictionnaryItem Album = new AlbumDictionnaryItem();
                            Album.BasePath = new DirectoryInfo(currentsAlbumDir);
                            Album.AlbumId = AlbumId;
                            _currentServer.Albums.Add(AlbumId, Album);
                            _currentAlbum = Album;
                        }

                        if (!Directory.Exists(currentsAlbumDir))
                        {
                            //Create it
                            Directory.CreateDirectory(currentsAlbumDir);
                        }
                    }
                }
                else
                {
                    throw new ApplicationException("Current server not set before using Album");
                }
            }

            public String GetImageFilename(PwgImageWPF aImageWPF, String strImageType)
                {
                    String retImgSrc = GetDefaultImage();
                    if (aImageWPF == null)
                    {
                        return retImgSrc;
                    }

                    if (_currentAlbum != null)
                    {
                        String localDir = Path.Combine(_currentAlbum.BasePath.FullName, strImageType);
                        if (!Directory.Exists(localDir))
                        {
                            Directory.CreateDirectory(localDir);
                        }

                        String localFile = Path.Combine(localDir, String.Format("{0}-{1}", aImageWPF.Id, aImageWPF.File));

                        if (!File.Exists(localFile))
                        {
                            retImgSrc = GetLoadImage();

                            ThreadPool.QueueUserWorkItem((WaitCallback)delegate
                            {
                                WebRequest request = HttpWebRequest.Create(aImageWPF.UrlElement);
                                WebResponse response = request.GetResponse();

                                //check the content type to assert that the file in the uri is an image
                                if (!response.ContentType.StartsWith("image"))
                                {
                                    throw new FileFormatException(aImageWPF.UrlElement, String.Format("Uri passed to ImageCacher does not return an image. Content is of type {0}.", response.ContentType));
                                }

                                //load the image from the stream
                                Image image = Image.FromStream(response.GetResponseStream());

                                //save it
                                image.Save(localFile);

                                switch (strImageType)
                                {
                                    case "Thumb" :
                                        aImageWPF.ImgSourceThumb = localFile;
                                        break;
                                    case "LowRes":
                                        aImageWPF.ImgSource = localFile; 
                                        break;
                                }

                            });
                        }
                        else
                        {
                            retImgSrc = localFile; 
                        }
                        return retImgSrc;
                    }
                    else
                    {
                        throw new ApplicationException("Current Album not set before using image cache.");
                    }
                }

            public void Dispose()
            {
                if (_aServerDictionnary != null)
                {
                    WriteServerDictionnaryToDisk(_aServerDictionnary);
                }
            }
        }

        #endregion singleton base class
}

}