using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Drawing;
using System.Drawing.Imaging;
using System.ComponentModel;
using PersistentObjects;
using System.Windows.Forms;

namespace FastGallery
{
    /// <summary>
    /// Settings related to a web gallery.
    /// </summary>
    [Serializable]
    class Gallery : Persistent, ICloneable
    {
        /// <summary>
        /// A name for the gallery that will form part of the URL.
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                if (value == null || value.Equals(Path.GetFileName(value)))// check is nothing more than a valid filename
                {
                    name = value;
                }
                else
                {
                    throw new Exception("Invalid name");
                }
            }
        }

        private string name;

        /// <summary>
        /// The full title for the gallery to appear on the page.
        /// </summary>
        /// <remarks>If no title is specified the Name value will be used.</remarks>
        public string Title
        {
            get
            {
                if (String.IsNullOrEmpty(title))
                {
                    return name;
                }
                else
                {
                    return title;
                }
            }
            set
            {
                title = value;
            }
        }

        private string title;

        /// <summary>
        /// The directory on disk for the gallery working files.
        /// </summary>
        internal string Directory
        {
            get
            {
                return System.IO.Path.Combine(Program.GetTempPath(), Name);
            }

        }

        /// <summary>
        /// The URL of the index page.
        /// </summary>
        internal string IndexPage()
        {
            return System.IO.Path.Combine(Directory, "index.html");
        }

        private string originalName;

        /// <summary>
        /// Build a gallery, using the program settings.
        /// </summary>
        public Gallery(Settings settings)
        {
            while (true)
            {
                settings.GalleryCounter++; // update counter
                settings.Save(Settings.Filename());// save straight away
                originalName = "Gallery " + settings.GalleryCounter;
                Name = originalName;

                if (!System.IO.Directory.Exists(Directory))
                {
                    System.IO.Directory.CreateDirectory(Directory);

                    break;
                }
            }
        }

        /// <summary>
        /// A full list of the images included in the gallery.
        /// </summary>
        public List<IncludedImage> IncludedImages
        {
            get { return includedImages; }
        }

        List<IncludedImage> includedImages = new List<IncludedImage>();

        /// <summary>
        /// The average dimensions of the edges of the thumbnails, in pixels.
        /// </summary>
        public int ThumbnailSize
        {
            get { return thumbnailSize; }
            set { thumbnailSize = value; }
        }

        private int thumbnailSize = 120;

        /// <summary>
        /// The number of thumbnails per line in the thumbnail page.
        /// </summary>
        public int ThumbnailsPerLine
        {
            get
            {
                return thumbnailsPerLine;
            }
            set
            {
                if (value < 1)
                {
                    throw new Exception("Thumbnails per line must be at least one");
                }
                thumbnailsPerLine = value;
            }
        }

        private int thumbnailsPerLine = 5;

        /// <summary>
        /// The maximum average dimensions of each edge of the full images.
        /// </summary>
        public int MaxImageWidth
        {
            get { return maxImageWidth; }
            set { maxImageWidth = value; }
        }

        private int maxImageWidth = 1024;

        /// <summary>
        /// The percentage quality to use in the saved Jpeg images
        /// </summary>
        public int JpegQuality
        {
            get { return jpegQuality; }
            set
            {
                if (value != jpegQuality)
                {
                    if (value < 1 || value > 100)
                    {
                        throw new Exception("Jpeg Quality should be set between 1 and 100");
                    }

                    jpegQuality = value;

                    foreach (IncludedImage includedImage in IncludedImages)
                    {
                        includedImage.LastSavedAs = null;
                    }
                }
            }
        }

        private int jpegQuality = 80;



        #region ICloneable Members

        /// <summary>
        /// Make a clone of the gallery
        /// </summary>
        public object Clone()
        {
            Gallery clone = (Gallery)MemberwiseClone();

            clone.includedImages = new List<IncludedImage>();
            foreach (IncludedImage includedImage in includedImages)
            {
                clone.IncludedImages.Add((IncludedImage)includedImage.Clone());
            }

            return clone;
        }

        #endregion

        /// <summary>
        /// Build a gallery.
        /// </summary>
        internal void Generate(BackgroundWorker backgroundWorker)
        {
            try
            {
                StringBuilder errors = new StringBuilder();
                Program.Settings.Save(Settings.Filename(), true);

                System.IO.Directory.CreateDirectory(Directory);

                System.IO.Directory.CreateDirectory(Path.Combine(Directory, @"images"));

                System.IO.Directory.CreateDirectory(Path.Combine(Directory, @"thumbs"));

                // copy text file from embedded resource to directory
                using (Stream s = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "Stylesheet.css"))
                {
                    using (StreamReader streamReader = new StreamReader(s))
                    {
                        using (TextWriter tw = new StreamWriter(System.IO.Path.Combine(Directory, "StyleSheet.css")))
                        {
                            while (!streamReader.EndOfStream)
                            {
                                tw.WriteLine(streamReader.ReadLine());
                            }
                        }
                    }
                }

                // build gallery
                using (TextWriter tw = new StreamWriter(IndexPage()))
                {
                    using (Stream s = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "GalleryHeader.htm"))
                    {
                        StreamReader streamReader = new StreamReader(s);

                        while (!streamReader.EndOfStream)
                        {
                            string line = streamReader.ReadLine();

                            if (line.Contains("<!--title-->"))
                            {
                                tw.WriteLine(Title);
                            }
                            else if (line.Contains("<!--errors-->"))
                            {
                                tw.WriteLine(errors);
                            }
                            else if (line.Contains("<!--gallery-->"))
                            {
                                int idx = 0;

                                bool openRow = false;

                                int thumbnailsSoFar = 0;

                                tw.WriteLine(@"<table>");

                                foreach (IncludedImage includedImage in includedImages)
                                {
                                    try
                                    {
                                        string useName = includedImage.Name;
                                        string extension = Path.GetExtension(useName).ToLower();

                                        if (!extension.Equals(".jpg") && !extension.Equals(".gif") && !extension.Equals(".png")) // supported formats
                                        {
                                            useName = Path.ChangeExtension(useName, "jpg");
                                        }

                                        string useNameThumbnail = Path.ChangeExtension(includedImage.Name, "jpg");

                                        {

                                            backgroundWorker.ReportProgress((idx * 100) / includedImages.Count, "Building gallery (loading " + includedImage.Name + ")");

                                            if (backgroundWorker.CancellationPending)
                                            {
                                                throw new CancelledException();
                                            }

                                            string fullPath = Path.Combine(Directory, Path.Combine("images", useName));

                                            Bitmap bitmap = null;

                                            // prepare main image
                                            if (!fullPath.Equals(includedImage.LastSavedAs) || !File.Exists(fullPath) || includedImage.LastSaveAsMaxWidth != MaxImageWidth || includedImage.LastSaveWithRotations != includedImage.Rotations)
                                            {
                                                backgroundWorker.ReportProgress((int)((0.2f + idx) * 100) / includedImages.Count, "Building gallery (sizing " + includedImage.Name + ")");

                                                if (backgroundWorker.CancellationPending)
                                                {
                                                    throw new CancelledException();
                                                }

                                                Image output;

                                                Image resized = null;

                                                bitmap = includedImage.GetBitmap();

                                                if (bitmap.Width > MaxImageWidth)
                                                {
                                                    resized = ResizeBitmap(bitmap, MaxImageWidth);
                                                    output = resized;
                                                }
                                                else
                                                {
                                                    output = bitmap;
                                                }

                                                backgroundWorker.ReportProgress((int)((0.4f + idx) * 100) / includedImages.Count, "Building gallery (saving " + includedImage.Name + ")");

                                                if (backgroundWorker.CancellationPending)
                                                {
                                                    throw new CancelledException();
                                                }

                                                ImageServices.SaveImage(output, fullPath, Program.Settings.Gallery.JpegQuality);

                                                if (resized != null)
                                                {
                                                    resized.Dispose();
                                                }

                                                includedImage.LastSavedAs = fullPath;
                                                includedImage.LastSaveAsMaxWidth = MaxImageWidth;
                                                includedImage.LastSaveWithRotations = includedImage.Rotations;

                                            }

                                            string fullPathThumbnail = Path.Combine(Directory, Path.Combine("thumbs", useNameThumbnail));

                                            // prepare thumbnail image
                                            if (!fullPathThumbnail.Equals(includedImage.LastSavedAsThumbnail) || !File.Exists(fullPathThumbnail) || includedImage.LastSavedAsThumbnailSize != ThumbnailSize || includedImage.LastSaveWithRotationsThumbnail != includedImage.Rotations)
                                            {
                                                backgroundWorker.ReportProgress((int)((0.6f + idx) * 100) / includedImages.Count, "Building gallery (sizing thumbnail " + useName + ")");

                                                if (backgroundWorker.CancellationPending)
                                                {
                                                    throw new CancelledException();
                                                }

                                                if (bitmap == null)
                                                {
                                                    bitmap = includedImage.GetBitmap();
                                                }

                                                float scale = (float)Math.Sqrt((double)(ThumbnailSize * ThumbnailSize) / (bitmap.Width * bitmap.Height));

                                                using (Bitmap output = ScaleBitmap(bitmap, scale))
                                                {

                                                    backgroundWorker.ReportProgress((int)((0.8f + idx) * 100) / includedImages.Count, "Building gallery (saving thumbnail " + useName + ")");

                                                    if (backgroundWorker.CancellationPending)
                                                    {
                                                        throw new CancelledException();
                                                    }

                                                    ImageServices.SaveImage(output, fullPathThumbnail, Program.Settings.Gallery.JpegQuality);

                                                }

                                            }

                                            includedImage.LastSavedAsThumbnailSize = ThumbnailSize;
                                            includedImage.LastSavedAsThumbnail = fullPathThumbnail;
                                            includedImage.LastSaveWithRotationsThumbnail = includedImage.Rotations;

                                            if (bitmap != null)
                                            {
                                                bitmap.Dispose();
                                            }

                                        }

                                        if (!openRow)
                                        {
                                            tw.WriteLine(@"<tr>");
                                            openRow = true;

                                        }

                                        tw.WriteLine("<td><a href=\"images/" + Uri.EscapeUriString(useName) + "\"><img src=\"thumbs/" + Uri.EscapeUriString(useNameThumbnail) + "\"></a></td>");
                                        thumbnailsSoFar++;

                                        if (thumbnailsSoFar == ThumbnailsPerLine)
                                        {
                                            tw.WriteLine(@"</tr>");
                                            openRow = false;
                                            thumbnailsSoFar = 0;
                                        }

                                    }
                                    catch (CancelledException exception)
                                    {
                                        throw exception;
                                    }
                                    catch (Exception e)
                                    {
                                        errors.AppendLine(@"<div>" + includedImage.Name + @":</div>");
                                        errors.AppendLine(@"<pre>" + e.ToString() + @":</pre>");

                                    }

                                    idx++;
                                }
                                if (openRow)
                                {
                                    tw.WriteLine(@"</tr>");
                                }
                                tw.WriteLine(@"</table>");


                            }
                            else
                            {
                                tw.WriteLine(line);
                            }
                        }


                    }
                }
            }
            catch (CancelledException cancelledException)
            {
                throw cancelledException;
            }
            catch (InvalidOperationException)
            {
                // this is collection collision .. benign so just cancel
                throw new CancelledException();
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message, "Error building gallery");
                throw new CancelledException();
            }
            //tw.Close();

        }

        /// <summary>
        /// A utility function to rescale bitmaps.
        /// </summary>
        /// <param name="image">The source image.</param>
        /// <param name="newWidth">The average edge dimensions of the resized image.</param>
        /// <returns>The resized image.</returns>
        private static Bitmap ResizeBitmap(Bitmap image, int newWidth)
        {

            float scale = (float)newWidth / image.Width;

            return ScaleBitmap(image, scale);
        }

        /// <summary>
        /// A utility function to rescale bitmaps.
        /// </summary>
        /// <param name="image">The source image.</param>
        /// <param name="scale">The fraction to scale the image by.</param>
        /// <returns>The resized image.</returns>
        private static Bitmap ScaleBitmap(Bitmap image, float scale)
        {
            return (Bitmap)ImageServices.ResizeImage(image, (int)(scale * image.Width), (int)(scale * image.Height));

        }

        /// <summary>
        /// Exception for cancelled builds.
        /// </summary>
        public class CancelledException : SystemException
        {
        }

        /// <summary>
        /// Current version. Alter to invalidate old saves.
        /// </summary>
        /// <returns>The current version number.</returns>
        public override int CurrentVersion()
        {
            return 207;
        }
    }
}