//   SparkleShare, a collaboration and sharing tool.
//   Copyright (C) 2010  Hylke Bons <hylkebons@gmail.com>
//
//   This program is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
//   This program is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//   GNU General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program. If not, see <http://www.gnu.org/licenses/>.


using System;
using System.IO;
using System.Diagnostics;
using System.Security.AccessControl;
using System.Text.RegularExpressions;
using System.Threading;

namespace SparkleLib {

    // Sets up a fetcher that can get remote folders
    public abstract class SparkleFetcherBase {

        public delegate void StartedEventHandler ();
        public delegate void FinishedEventHandler (string [] warnings);
        public delegate void FailedEventHandler ();
        public delegate void ProgressChangedEventHandler (double percentage);

        public event StartedEventHandler Started;
        public event FinishedEventHandler Finished;
        public event FailedEventHandler Failed;
        public event ProgressChangedEventHandler ProgressChanged;

        protected string target_folder;
        protected string remote_url;

        private Thread thread;

        
        public SparkleFetcherBase (string server, string remote_folder, string target_folder)
        {
            this.target_folder = target_folder;
            this.remote_url    = server + "/" + remote_folder;
        }


        public abstract bool Fetch ();
        public abstract string [] Warnings { get; }

        // Clones the remote repository
        public void Start ()
        {
            SparkleHelpers.DebugInfo ("Fetcher", "[" + this.target_folder + "] Fetching folder: " + this.remote_url);

            if (Started != null)
                Started ();

            if (Directory.Exists (this.target_folder))
                Directory.Delete (this.target_folder, true);

            string host = GetHost (this.remote_url);

            if (String.IsNullOrEmpty (host)) {
                if (Failed != null)
                    Failed ();

                return;
            }

            DisableHostKeyCheckingForHost (host);

            this.thread = new Thread (new ThreadStart (delegate {
                if (Fetch ()) {
                    SparkleHelpers.DebugInfo ("Fetcher", "Finished");

                    EnableHostKeyCheckingForHost (host);

                    if (Finished != null)
                        Finished (Warnings);

                } else {
                    SparkleHelpers.DebugInfo ("Fetcher", "Failed");

                    EnableHostKeyCheckingForHost (host);

                    if (Failed != null)
                        Failed ();
                }
            }));

            this.thread.Start ();
        }


        public virtual void Stop ()
        {
            this.thread.Abort ();
            this.thread.Join ();
        }


        public string RemoteUrl {
            get {
                return this.remote_url;
            }
        }


        public void Dispose ()
        {
            if (this.thread != null) {
                this.thread.Abort ();
                this.thread.Join ();
            }
        }

        
        protected void OnProgressChanged (double percentage) {
            if (ProgressChanged != null)
                ProgressChanged (percentage);    
        }
    
        
        private void DisableHostKeyCheckingForHost (string host)
        {
            string path = SparkleConfig.DefaultConfig.HomePath;

            if (!(SparkleBackend.Platform == PlatformID.Unix ||
                  SparkleBackend.Platform == PlatformID.MacOSX)) {

                path = Environment.ExpandEnvironmentVariables ("%HOMEDRIVE%%HOMEPATH%");
            }

            string ssh_config_path      = Path.Combine (path, ".ssh");
            string ssh_config_file_path = SparkleHelpers.CombineMore (path, ".ssh", "config");
            string ssh_config           = "\n# <SparkleShare>" +
                                          "\nHost " + host +
                                          "\n\tStrictHostKeyChecking no" +
                                          "\n# </SparkleShare>";

            if (!Directory.Exists (ssh_config_path))
                Directory.CreateDirectory (ssh_config_path);

            if (File.Exists (ssh_config_file_path)) {
                TextWriter writer = File.AppendText (ssh_config_file_path);
                writer.Write (ssh_config);
                writer.Close ();

            } else {
                File.WriteAllText (ssh_config_file_path, ssh_config);
            }

            Chmod644 (ssh_config_file_path);
            SparkleHelpers.DebugInfo ("Fetcher", "Disabled host key checking for " + host);
        }
        

        private void EnableHostKeyCheckingForHost (string host)
        {
            string path = SparkleConfig.DefaultConfig.HomePath;

            if (SparkleBackend.Platform != PlatformID.Unix &&
                SparkleBackend.Platform != PlatformID.MacOSX) {

                path = Environment.ExpandEnvironmentVariables ("%HOMEDRIVE%%HOMEPATH%");
            }

            string ssh_config_file_path = SparkleHelpers.CombineMore (path, ".ssh", "config");

            if (File.Exists (ssh_config_file_path)) {
                string current_ssh_config = File.ReadAllText (ssh_config_file_path);

                current_ssh_config = current_ssh_config.Trim ();
                string [] lines = current_ssh_config.Split ('\n');
                string new_ssh_config = "";
                bool in_sparkleshare_section = false;

                foreach (string line in lines) {
                    if (line.StartsWith ("# <SparkleShare>")) {
                        in_sparkleshare_section = true;
                        continue;
                    }

                    if (line.StartsWith ("# </SparkleShare>")) {
                        in_sparkleshare_section = false;
                        continue;
                    }

                    if (in_sparkleshare_section)
                        continue;

                    new_ssh_config += line + "\n"; // do not use Environment.NewLine because file is in unix format
                }

                if (string.IsNullOrEmpty (new_ssh_config.Trim ())) {
                    File.Delete (ssh_config_file_path);

                } else {
                    File.WriteAllText (ssh_config_file_path, new_ssh_config.Trim ());
                    Chmod644 (ssh_config_file_path);
                }
            }

            SparkleHelpers.DebugInfo ("Fetcher", "Enabled host key checking for " + host);
        }


        private string GetHost (string url)
        {
            Regex regex = new Regex (@"(@|://)([a-z0-9\.-]+)(/|:)");
            Match match = regex.Match (url);

            if (match.Success)
                return match.Groups [2].Value;
            else
                return null;
        }
        
        
        private void Chmod644 (string file_path)
        {
            // Hack to be able to set the permissions on a file
            // that OpenSSH still likes without resorting to Mono.Unix
            FileInfo file_info   = new FileInfo (file_path);
            file_info.Attributes = FileAttributes.ReadOnly;
			file_info.Attributes = FileAttributes.Normal;
        }
    }
}