BizHawk/BizHawk.Client.EmuHawk/movie/PlayMovie.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;

using BizHawk.Common;
using BizHawk.Client.Common;

namespace BizHawk.Client.EmuHawk
{
    public partial class PlayMovie : Form
    {
        private List<IMovie> _movieList = new List<IMovie>();
        private bool _sortReverse;
        private string _sortedCol;

        private bool _sortDetailsReverse;
        private string _sortedDetailsCol;
        
        public PlayMovie()
        {
            InitializeComponent();
            MovieView.QueryItemText += MovieView_QueryItemText;
            MovieView.VirtualMode = true;
            _sortReverse = false;
            _sortedCol = String.Empty;

            _sortDetailsReverse = false;
            _sortedDetailsCol = String.Empty;
        }

        void MovieView_QueryItemText(int index, int column, out string text)
        {
            text = String.Empty;
            if (column == 0) //File
            {
                text = Path.GetFileName(_movieList[index].Filename);
            }
            if (column == 1) //System
            {
                text = _movieList[index].Header.SystemID;
            }
            if (column == 2) //Game
            {
                text = _movieList[index].Header.GameName;
            }
            if (column == 3) //Time
            {
                text = _movieList[index].Time.ToString(@"hh\:mm\:ss\.fff");
            }
        }

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

        private void Run()
        {
            var indices = MovieView.SelectedIndices;
            if (indices.Count > 0) //Import file if necessary
            {
                GlobalWin.MainForm.StartNewMovie(_movieList[MovieView.SelectedIndices[0]], false);
            }
        }

        private void OK_Click(object sender, EventArgs e)
        {
            Run();
            Global.MovieSession.ReadOnly = ReadOnlyCheckBox.Checked;
            Close();
        }

        private void BrowseMovies_Click(object sender, EventArgs e)
        {
            var ofd = new OpenFileDialog { InitialDirectory = PathManager.MakeAbsolutePath(Global.Config.PathEntries.MoviesPathFragment, null) };
            var filter = "Movie Files (*." + Global.Config.MovieExtension + ")|*." + Global.Config.MovieExtension + "|Savestates|*.state|All Files|*.*";
            ofd.Filter = filter;

            var result = ofd.ShowHawkDialog();
            if (result == DialogResult.OK)
            {
                var file = new FileInfo(ofd.FileName);
                if (!file.Exists)
                {
                    return;
                }
                else
                {
                    if (file.Extension.ToUpper() == "STATE")
                    {
                        var movie = new Movie(file.FullName);
                        movie.Load(); //State files will have to load everything unfortunately
                        if (movie.FrameCount == 0)
                        {
                            MessageBox.Show("No input log detected in this savestate, aborting", "Can not load file", MessageBoxButtons.OK,
                                            MessageBoxIcon.Hand);
                            return;
                        }
                    }

                    int? index = AddMovieToList(ofd.FileName, true);
                    if (index.HasValue)
                    {
                        MovieView.SelectedIndices.Clear();
                        MovieView.setSelection(index.Value);
                        MovieView.SelectItem(index.Value, true);
                    }
                }
            }
        }

        private void AddStateToList(string filename)
        {
            using (var file = new HawkFile(filename))
            {
                if (file.Exists)
                {
                    if (!IsDuplicateOf(filename).HasValue)
                    {
                        var movie = new Movie(file.CanonicalFullPath);
                        movie.Load(); //State files will have to load everything unfortunately
                        if (movie.FrameCount > 0)
                        {
                            _movieList.Add(movie);
                            _sortReverse = false;
                            _sortedCol = String.Empty;
                        }
                    }
                }
            }
        }

        private int? AddMovieToList(string filename, bool force)
        {
            using (var file = new HawkFile(filename))
            {
                if (!file.Exists)
                {
                    return null;
                }
                else
                {
                    int? index = IsDuplicateOf(filename);
                    if (!index.HasValue)
                    {
                        PreLoadMovieFile(file, force);
                        MovieView.ItemCount = _movieList.Count;
                        UpdateList();

                        _sortReverse = false;
                        _sortedCol = String.Empty;
                        index = _movieList.Count - 1;
                    }
                    return index;
                }
            }
        }

        private int? IsDuplicateOf(string filename)
        {
            for (int i = 0; i < _movieList.Count; i++)
            {
                if (_movieList[i].Filename == filename)
                {
                    return i;
                }
            }

            return null;
        }

        private void PreLoadMovieFile(HawkFile hf, bool force)
        {
            var movie = new Movie(hf.CanonicalFullPath);
            movie.PreLoadText(hf);
            try
            {
                //Don't do this from browse
                if (movie.Header[HeaderKeys.GAMENAME] == Global.Game.Name ||
                    Global.Config.PlayMovie_MatchGameName == false || force)
                {
                    _movieList.Add(movie);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        private void UpdateList()
        {
            MovieView.Refresh();
            UpdateMovieCount();
        }

        private void UpdateMovieCount()
        {
            MovieCount.Text = _movieList.Count + " movie"
                + (_movieList.Count != 1 ? "s" : String.Empty);
        }

        private void PreHighlightMovie()
        {
            if (Global.Game == null) return;
            var Indices = new List<int>();

            //Pull out matching names
            for (int i = 0; i < _movieList.Count; i++)
            {
                if (PathManager.FilesystemSafeName(Global.Game) == _movieList[i].Header.GameName)
                {
                    Indices.Add(i);
                }
            }
            if (Indices.Count == 0) return;
            if (Indices.Count == 1)
            {
                HighlightMovie(Indices[0]);
                return;
            }

            //Prefer tas files
            var TAS = new List<int>();
            for (int i = 0; i < Indices.Count; i++)
            {
                if (Path.GetExtension(_movieList[Indices[i]].Filename).ToUpper() == "." + Global.Config.MovieExtension)
                {
                    TAS.Add(i);
                }
            }

            if (TAS.Count == 1)
            {
                HighlightMovie(TAS[0]);
                return;
            }
            else if (TAS.Count > 1)
            {
                Indices = new List<int>(TAS);
            }

            //Final tie breaker - Last used file
            var file = new FileInfo(_movieList[Indices[0]].Filename);
            var time = file.LastAccessTime;
            int mostRecent = Indices.First();
            for (int i = 1; i < Indices.Count; i++)
            {
                file = new FileInfo(_movieList[Indices[0]].Filename);
                if (file.LastAccessTime > time)
                {
                    time = file.LastAccessTime;
                    mostRecent = Indices[i];
                }
            }

            HighlightMovie(mostRecent);
            return;

        }

        private void HighlightMovie(int index)
        {
            MovieView.SelectedIndices.Clear();
            MovieView.setSelection(index);
            MovieView.SelectItem(index, true);
        }

        private void ClearList()
        {
            _movieList.Clear();
            MovieView.ItemCount = 0;
            MovieView.Update();
        }

        private void ScanFiles()
        {
            ClearList();

            var directory = PathManager.MakeAbsolutePath(Global.Config.PathEntries.MoviesPathFragment, null);
            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            Directory.GetFiles(directory, "*." + Global.Config.MovieExtension)
                    .ToList()
                    .ForEach(file => AddMovieToList(file, force: false));

            if (Global.Config.PlayMovie_ShowStateFiles)
            {
                Directory.GetFiles(directory, "*.state")
                    .ToList()
                    .ForEach(file => AddStateToList(file));
            }

            if (Global.Config.PlayMovie_IncludeSubdir)
            {
                var subs = Directory.GetDirectories(directory);
                foreach (var dir in subs)
                {
                    Directory.GetFiles(dir, "*." + Global.Config.MovieExtension)
                    .ToList()
                    .ForEach(file => AddMovieToList(file, force: false));

                    Directory.GetFiles(dir, "*.state")
                    .ToList()
                    .ForEach(file => AddStateToList(file));
                }
            }
        }

        private void PlayMovie_Load(object sender, EventArgs e)
        {
            IncludeSubDirectories.Checked = Global.Config.PlayMovie_IncludeSubdir;
            ShowStateFiles.Checked = Global.Config.PlayMovie_ShowStateFiles;
            MatchGameNameCheckBox.Checked = Global.Config.PlayMovie_MatchGameName;
            ScanFiles();
            PreHighlightMovie();
        }

        private void MovieView_SelectedIndexChanged(object sender, EventArgs e)
        {
            toolTip1.SetToolTip(DetailsView, String.Empty);
            DetailsView.Items.Clear();
            if (MovieView.SelectedIndices.Count < 1)
            {
                OK.Enabled = false;
                return;
            }
            else
            {
                OK.Enabled = true;
            }

            int firstIndex = MovieView.SelectedIndices[0];
            MovieView.ensureVisible(firstIndex);

            foreach (var kvp in _movieList[firstIndex].Header)
            {
                var item = new ListViewItem(kvp.Key);
                item.SubItems.Add(kvp.Value);

                switch (kvp.Key)
                {
                    case HeaderKeys.SHA1:
                        if (kvp.Value != Global.Game.Hash)
                        {
                            item.BackColor = Color.Pink;
                            toolTip1.SetToolTip(DetailsView, "Current SHA1: " + Global.Game.Hash);
                        }
                        break;
                    case HeaderKeys.MOVIEVERSION:
                        if (kvp.Value != HeaderKeys.MovieVersion1)
                        {
                            item.BackColor = Color.Yellow;
                        }
                        break;
                    case HeaderKeys.EMULATIONVERSION:
                        if (kvp.Value != VersionInfo.GetEmuVersion())
                        {
                            item.BackColor = Color.Yellow;
                        }
                        break;
                    case HeaderKeys.PLATFORM:
                        if (kvp.Value != Global.Game.System)
                        {
                            item.BackColor = Color.Pink;
                        }
                        break;
                }

                DetailsView.Items.Add(item);
            }

            var FpsItem = new ListViewItem("Fps");
            FpsItem.SubItems.Add(String.Format("{0:0.#######}", _movieList[firstIndex].Fps));
            DetailsView.Items.Add(FpsItem);

            var FramesItem = new ListViewItem("Frames");
            FramesItem.SubItems.Add(_movieList[firstIndex].FrameCount.ToString());
            DetailsView.Items.Add(FramesItem);
            CommentsBtn.Enabled = _movieList[firstIndex].Header.Comments.Any();
            SubtitlesBtn.Enabled = _movieList[firstIndex].Header.Subtitles.Any();
        }

      
        private void button1_Click(object sender, EventArgs e)
        {
            var indices = MovieView.SelectedIndices;
            if (indices.Count > 0)
            {
                var form = new EditCommentsForm();
                form.GetMovie(_movieList[MovieView.SelectedIndices[0]]);
                form.Show();
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            var indices = MovieView.SelectedIndices;
            if (indices.Count > 0)
            {
                var s = new EditSubtitlesForm { ReadOnly = true };
                s.GetMovie(_movieList[MovieView.SelectedIndices[0]]);
                s.Show();
            }
        }

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

        private void MovieView_DragEnter(object sender, DragEventArgs e)
        {
            e.Effect = e.Data.GetDataPresent(DataFormats.FileDrop) ? DragDropEffects.Copy : DragDropEffects.None;
        }

        private void MovieView_DragDrop(object sender, DragEventArgs e)
        {
            var filePaths = (string[])e.Data.GetData(DataFormats.FileDrop);

            filePaths
                .Where(path => Path.GetExtension(path) == "." + Global.Config.MovieExtension)
                .ToList()
                .ForEach(path => AddMovieToList(path, force: true));
        }

        private void MovieView_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            OrderColumn(e.Column);
        }

        private void OrderColumn(int columnToOrder)
        {
            var columnName = MovieView.Columns[columnToOrder].Text;
            if (_sortedCol != columnName)
            {
                _sortReverse = false;
            }

            switch (columnName)
            {
                case "File":
                    if (_sortReverse)
                    {
                        _movieList = _movieList
                            .OrderByDescending(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.SystemID)
                            .ThenBy(x => x.Header.GameName)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    else
                    {
                        _movieList = _movieList
                            .OrderBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.SystemID)
                            .ThenBy(x => x.Header.GameName)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    break;
                case "SysID":
                    if (_sortReverse)
                    {
                        _movieList = _movieList
                            .OrderByDescending(x => x.Header.SystemID)
                            .ThenBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.GameName)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    else
                    {
                        _movieList = _movieList
                            .OrderBy(x => x.Header.SystemID)
                            .ThenBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.GameName)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    break;
                case "Game":
                    if (_sortReverse)
                    {
                        _movieList = _movieList
                            .OrderByDescending(x => x.Header.GameName)
                            .ThenBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.SystemID)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    else
                    {
                        _movieList = _movieList
                            .OrderBy(x => x.Header.GameName)
                            .ThenBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.SystemID)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    break;
                case "Length (est.)":
                    if (_sortReverse)
                    {
                        _movieList = _movieList
                            .OrderByDescending(x => x.FrameCount)
                            .ThenBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.SystemID)
                            .ThenBy(x => x.FrameCount)
                            .ToList();
                    }
                    else
                    {
                        _movieList = _movieList
                            .OrderBy(x => x.FrameCount)
                            .ThenBy(x => Path.GetFileName(x.Filename))
                            .ThenBy(x => x.Header.SystemID)
                            .ThenBy(x => x.Header.GameName)
                            .ToList();
                    }
                    break;
            }

            _sortedCol = columnName;
            _sortReverse = !_sortReverse;
            MovieView.Refresh();
        }

        private void IncludeSubDirectories_CheckedChanged(object sender, EventArgs e)
        {
            Global.Config.PlayMovie_IncludeSubdir = IncludeSubDirectories.Checked;
            ScanFiles();
            PreHighlightMovie();
        }

        private void ShowStateFiles_CheckedChanged(object sender, EventArgs e)
        {
            Global.Config.PlayMovie_ShowStateFiles = ShowStateFiles.Checked;
            ScanFiles();
            PreHighlightMovie();
        }

        private void Scan_Click(object sender, EventArgs e)
        {
            ScanFiles();
            PreHighlightMovie();
        }

        private void MatchGameNameCheckBox_CheckedChanged(object sender, EventArgs e)
        {
            Global.Config.PlayMovie_MatchGameName = MatchGameNameCheckBox.Checked;
            ScanFiles();
            PreHighlightMovie();
        }

        private void MovieView_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Control && e.KeyCode == Keys.C)
            {
                var indexes = MovieView.SelectedIndices;
                if (indexes.Count > 0)
                {
                    var copyStr = new StringBuilder();
                    foreach (int index in indexes)
                    {
                        copyStr
                            .Append(_movieList[index].Filename).Append('\t')
                            .Append(_movieList[index].Header.SystemID).Append('\t')
                            .Append(_movieList[index].Header.GameName).Append('\t')
                            .Append(_movieList[index].Time.ToString(@"hh\:mm\:ss\.fff"))
                            .AppendLine();

                        Clipboard.SetDataObject(copyStr.ToString());
                    }
                }
            }
        }

        private void DetailsView_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            OrderDetailsColumn(e.Column);
        }

        /// <summary>
        /// Takes the values from DetailView and puts them in a List of Detail classes, this list is then sorted and put back in the DetailView
        /// </summary>
        /// <param name="columnToOrder"></param>
        private void OrderDetailsColumn(int columnToOrder)
        {
            List<MovieDetails> detailsList = new List<MovieDetails>();
            for (int i = 0; i < DetailsView.Items.Count; i++)
            {
                detailsList.Add(new MovieDetails { keys = DetailsView.Items[i].Text, values = DetailsView.Items[i].SubItems[1].Text, backgroundColor = DetailsView.Items[i].BackColor });
            }
            var columnName = DetailsView.Columns[columnToOrder].Text;
            if (_sortedDetailsCol != columnName)
            {
                _sortDetailsReverse = false;
            }
            switch (columnName)
            {
                    //Header, Value
                case "Header":
                    if (_sortDetailsReverse)
                    {
                        detailsList = detailsList
                            .OrderByDescending(x => x.keys)
                            .ThenBy(x => x.values).ToList();
                    }
                    else
                    {
                        detailsList = detailsList
                           .OrderBy(x => x.keys)
                           .ThenBy(x => x.values).ToList();
                    }
                    break;
                case "Value":
                    if (_sortDetailsReverse)
                    {
                        detailsList = detailsList
                            .OrderByDescending(x => x.values)
                            .ThenBy(x => x.keys).ToList();
                    }
                    else
                    {
                        detailsList = detailsList
                            .OrderBy(x => x.values)
                            .ThenBy(x => x.keys).ToList();
                    }
                    break;
            }
            int firstIndex = MovieView.SelectedIndices[0];
            DetailsView.Items.Clear();
            foreach (var detail in detailsList)
            {
                ListViewItem item = new ListViewItem { Text = detail.keys, BackColor = detail.backgroundColor };
                item.SubItems.Add(detail.values);
                DetailsView.Items.Add(item);
            }
            _sortedDetailsCol = columnName;
            _sortDetailsReverse = !_sortDetailsReverse;
        }
    }
}