using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using ObjectEditors;

namespace FastGallery
{
    /// <summary>
    /// An application to build simple photo galleries for the web.
    /// </summary>
    public partial class FastGallery : Form
    {
        /// <summary>
        /// Constructor
        /// </summary>
        public FastGallery()
        {
            InitializeComponent();

            galleryObjectEditor.Target = Program.Settings.Gallery;
            includedImagesCollectionEditor.Target = Program.Settings.Gallery.IncludedImages;
            webBrowser1.StatusTextChanged += new EventHandler(webBrowser1_StatusTextChanged);
            webBrowser1.ProgressChanged += new WebBrowserProgressChangedEventHandler(webBrowser1_ProgressChanged);


        }

        void webBrowser1_ProgressChanged(object sender, WebBrowserProgressChangedEventArgs e)
        {
            if (e.CurrentProgress == 0)
            {
                toolStripProgressBar1.Visible = false;
            }
            else
            {
                toolStripProgressBar1.Maximum = (int)e.MaximumProgress;
                toolStripProgressBar1.Value = (int)e.CurrentProgress;
            }
        }

        void webBrowser1_StatusTextChanged(object sender, EventArgs e)
        {
            toolStripStatusLabel1.Text = webBrowser1.StatusText;
        }

        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void addImagesToolStripMenuItem_Click(object sender, EventArgs e)
        {

            if (!String.IsNullOrEmpty(Program.Settings.LastPath))
            {
                openFileDialog1.InitialDirectory = Program.Settings.LastPath;
            }

            switch (openFileDialog1.ShowDialog())
            {
                case DialogResult.OK:
                    foreach (string name in openFileDialog1.FileNames)
                    {

                        Program.Settings.Gallery.IncludedImages.Add(new IncludedImage(name));
                        Program.Settings.LastPath = System.IO.Path.GetDirectoryName(name);
                    }
                    break;
                default:
                    break;

            }

        }

        private void imageSetBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            if (pictureBox1.Image != null)
            {
                pictureBox1.Image.Dispose();
                pictureBox1.Image = null;
            }


            IncludedImage includedImage = (IncludedImage)e.Argument;

            Image image;
            try
            {
                image = includedImage.GetBitmap();
            }
            catch (OutOfMemoryException)
            {
                return;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error displaying image");
                return;

            }

            pictureBox1.Image = image;
        }

        private void includedImagesCollectionEditor_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (!imageSetBackgroundWorker.IsBusy) //could used queued worker here
            {
                if (Program.Settings.Gallery.IncludedImages.Count == includedImagesCollectionEditor.Items.Count) // may be in the process of being updated
                {
                    if (includedImagesCollectionEditor.SelectedIndices.Count > 0)
                    {
                        imageSetBackgroundWorker.RunWorkerAsync(Program.Settings.Gallery.IncludedImages[includedImagesCollectionEditor.SelectedIndices[0]]);
                    }
                }
            }
        }

        private void newGalleryToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Program.Settings.Gallery = new Gallery(Program.Settings);

            galleryObjectEditor.Target = Program.Settings.Gallery; // now a different object
            includedImagesCollectionEditor.Target = Program.Settings.Gallery.IncludedImages; // now a different object
        }

        private bool rebuildGallery = false;

        private void galleryValuesChanged(object sender, EventArgs e)
        {
            GalleryValuesChanged();
        }

        internal void GalleryValuesChanged()
        {
            if (galleryBuildVisualBackgroundWorker.IsBusy)
            {
                rebuildGallery = true;
                galleryBuildVisualBackgroundWorker.CancelAsync();
            }
            else
            {
                galleryBuildVisualBackgroundWorker.Visible = true;
                galleryBuildVisualBackgroundWorker.RunWorkerAsync();
            }
        }


        private void galleryBuildVisualBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {

            Gallery gallery = Program.Settings.Gallery;// (Gallery)Program.Settings.Gallery.Clone();

            try
            {
                gallery.Generate(galleryBuildVisualBackgroundWorker.GetBackgroundWorker());
                webBrowser1.Url = new System.Uri(gallery.IndexPage());
            }
            catch (Gallery.CancelledException)
            {
                e.Cancel = true;
            }
        }

        private void galleryBuildVisualBackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (rebuildGallery)
            {
                rebuildGallery = false;
                galleryBuildVisualBackgroundWorker.RunWorkerAsync(); // re-run
            }
            else
            {
                galleryBuildVisualBackgroundWorker.Visible = false;
            }
        }

        private void FastGallery_FormClosed(object sender, FormClosedEventArgs e)
        {
            try
            {
                System.IO.Directory.Delete(Program.GetTempPath(), true);
            }
            catch
            {

            }
        }

        private void galleryInBrowserToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (WaitForGalleryToBuild())
            {
                System.Diagnostics.Process process = new System.Diagnostics.Process();

                process.StartInfo.UseShellExecute = true;

                process.StartInfo.FileName = Program.Settings.Gallery.IndexPage();

                process.Start();
            }
        }

        private void includedImagesCollectionEditor_DragDrop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                foreach (string fileName in (string[])e.Data.GetData(DataFormats.FileDrop))
                {
                    Program.Settings.Gallery.IncludedImages.Add(new IncludedImage(fileName));
                }
            }
        }

        private void includedImagesCollectionEditor_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                e.Effect = DragDropEffects.Copy;
            }
        }


        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new About().ShowDialog();
        }

        private void rotateLeftToolStripButton_Click(object sender, EventArgs e)
        {
            foreach (int index in includedImagesCollectionEditor.SelectedIndices)
            {
                IncludedImage includedImage = Program.Settings.Gallery.IncludedImages[index];
                includedImage.RotateLeft();
                if (!imageSetBackgroundWorker.IsBusy) //could used queued worker here
                {
                    imageSetBackgroundWorker.RunWorkerAsync(includedImage);
                }
            }
        }

        private void rotateRightToolStripButton_Click(object sender, EventArgs e)
        {
            foreach (int index in includedImagesCollectionEditor.SelectedIndices)
            {
                IncludedImage includedImage = Program.Settings.Gallery.IncludedImages[index];
                includedImage.RotateRight();
                if (!imageSetBackgroundWorker.IsBusy) //could used queued worker here
                {
                    imageSetBackgroundWorker.RunWorkerAsync(includedImage);
                }
            }
        }

        private void homeToolStripButton_Click(object sender, EventArgs e)
        {
            webBrowser1.Url = new System.Uri(Program.Settings.Gallery.IndexPage());
        }

        private void backToolStripButton_Click(object sender, EventArgs e)
        {
            webBrowser1.GoBack();
        }

        private void forwardToolStripButton_Click(object sender, EventArgs e)
        {
            webBrowser1.GoForward();
        }

        private void webBrowser1_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
        {
            string imagePath = Path.Combine(Program.Settings.Gallery.Directory, @"images");
            if (e.Url.LocalPath.StartsWith(imagePath))
            {
                string remainder = e.Url.LocalPath.Substring(imagePath.Length + 1);

                foreach (ListViewItem listViewItem in includedImagesCollectionEditor.Items)
                {
                    IncludedImage includedImage = (IncludedImage)listViewItem.Tag;
                    listViewItem.Selected = includedImage.Name.Equals(remainder);
                }

                includedImagesCollectionEditor.HideSelection = false;
            }

        }

        private void includedImagesCollectionEditor_Leave(object sender, EventArgs e)
        {
            includedImagesCollectionEditor.HideSelection = true;
        }

        private void removeToolStripButton_Click(object sender, EventArgs e)
        {
            includedImagesCollectionEditor.DeleteSelectedItems();
        }


        private void publishViaFTPToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Publish ftpDialog = new Publish();
            ftpDialog.FastGallery = this;
            ftpDialog.Show();
        }

        private void settingsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ObjectEditorForm objectEditorForm = new ObjectEditorForm(Program.Settings.Gallery, "Gallery settings");
            objectEditorForm.ShowDialog();
        }
        
        /// <summary>
        /// Waits for the background operation to complete, and informs the user what's going on.
        /// </summary>
        internal bool WaitForGalleryToBuild()
        {
            if (galleryBuildVisualBackgroundWorker.Visible)
            {
                PleaseWait pleaseWait = new PleaseWait();
                galleryBuildVisualBackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(pleaseWait.galleryBuildVisualBackgroundWorker_ProgressChanged);
                galleryBuildVisualBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(pleaseWait.galleryBuildVisualBackgroundWorker_RunWorkerCompleted);
                pleaseWait.ShowDialog();
                galleryBuildVisualBackgroundWorker.ProgressChanged -= pleaseWait.galleryBuildVisualBackgroundWorker_ProgressChanged;
                galleryBuildVisualBackgroundWorker.RunWorkerCompleted -= pleaseWait.galleryBuildVisualBackgroundWorker_RunWorkerCompleted;

            }

            return !galleryBuildVisualBackgroundWorker.Visible; // still visible ? still being built
        }

        private void openToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();

            openFileDialog.DefaultExt = "gal";
            openFileDialog.Filter = "FastGallery gallery (*." + openFileDialog.DefaultExt + ")|*." + openFileDialog.DefaultExt;

            switch (openFileDialog.ShowDialog())
            {
                case DialogResult.OK:
                    try
                    {
                        Program.Settings.Gallery = (Gallery)Gallery.Load(openFileDialog.FileName);

                        galleryObjectEditor.Target = Program.Settings.Gallery;
                        includedImagesCollectionEditor.Target = Program.Settings.Gallery.IncludedImages;

                        Program.Settings.MostRecentFilename = openFileDialog.FileName;
                    }
                    catch (Exception exception)
                    {
                        MessageBox.Show(exception.Message, "An error occurred");
                    }
                    break;
                default:
                    break;
            }

        }

        private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveGallery();
        }

        private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveGalleryAs();
        }

        /// <summary>
        /// Lets the user save the gallery setup file with a name of his or her chosing.
        /// </summary>
        private void SaveGalleryAs()
        {
            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.DefaultExt = "gal";
            saveFileDialog.Filter = "FastGallery gallery  (*." + saveFileDialog.DefaultExt + ")|*." + saveFileDialog.DefaultExt;
            saveFileDialog.AddExtension = true;
            saveFileDialog.FileName = saveFileDialog.FileName;
            switch (saveFileDialog.ShowDialog(this))
            {
                case DialogResult.OK:
                    Program.Settings.MostRecentFilename = saveFileDialog.FileName;
                    SaveGallery();
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// Lets the user save the gallery under the existing filename.
        /// </summary>
        private void SaveGallery()
        {
            if (Program.Settings.MostRecentFilename == null)
            {
                SaveGalleryAs();
            }
            else
            {
                try
                {
                    Program.Settings.Gallery.Save(Program.Settings.MostRecentFilename);
                }
                catch (Exception exception)
                {
                    MessageBox.Show(exception.Message, "An error occurred");
                }
            }
        }

        private void optionsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new ObjectEditorForm(Program.Settings, "Program settings").ShowDialog();
        }

        private void toolbarToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mainToolStrip.Visible = !mainToolStrip.Visible;
        }

        private void toolsToolStripMenuItem_DropDownOpening(object sender, EventArgs e)
        {
            toolbarToolStripMenuItem.Checked = mainToolStrip.Visible;
        }

        private void welcomeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Welcome welcome = new Welcome();
            welcome.ShowDialog();
        }

        private void FastGallery_Load(object sender, EventArgs e)
        {
            if (Program.Settings.ShowStartupGuide)
            {
                Program.Settings.ShowStartupGuide = false;
                Welcome welcome = new Welcome();
                welcome.Location = new Point(Location.X + (Width - welcome.Width) / 2, Location.Y + (Height - welcome.Height) / 2);
                welcome.Show();              
            }

        }
    }


}