using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;

namespace OpenTap
{
    internal interface IFileLock : IDisposable
    {
        bool WaitOne();
        bool WaitOne(TimeSpan timeout);
        bool WaitOne(int ms);
        WaitHandle WaitHandle { get; }
        void Release();
    }

    internal static class FileLock
    {
        public static IFileLock Create(string file)
        {
            if (OperatingSystem.Current == OperatingSystem.Windows) return new Win32FileLock(file);
            if (OperatingSystem.Current == OperatingSystem.MacOS) return new MacOSFileLock(file);
            return new PosixFileLock(file);
        }
    }

    /// <summary>
    /// Note that this implementation is not thread-safe, unlike the other implementations
    /// </summary>
    class MacOSFileLock : IFileLock
    {
        private readonly ManualResetEvent _waitHandle;
        private readonly string name;

        public MacOSFileLock(string file)
        {
            _waitHandle = new ManualResetEvent(false);
            name = file;
        }

        public void Dispose()
        {
            Release();
        }

        public bool WaitOne()
        {
            while (true)
            {
                // Keep retrying waiting with a timeout until it succeeds
                if (WaitOne(1000)) return true;
            }
        }

        public bool WaitOne(TimeSpan timeout)
        {
            // If the fileLock is not null, we are already holding this mutex.
            if (fileLock != null) return true;
            var sw = Stopwatch.StartNew();
            do
            {
                // File exists -- the named mutex is locked
                if (File.Exists(name))
                {
                    var remaining = timeout - sw.Elapsed;
                    if (remaining.TotalMilliseconds > 1)
                        Thread.Sleep(1);
                    else Thread.Yield();
                }
                // Otherwise, create the file, thereby claiming the mutex
                else
                {
                    fileLock = File.Create(name, 0, FileOptions.DeleteOnClose);
                    _waitHandle.Set();
                    return true;
                }
            } while (sw.Elapsed < timeout);

            return false;
        }

        public bool WaitOne(int ms)
        {
            return WaitOne(TimeSpan.FromMilliseconds(ms));
        }

        public WaitHandle WaitHandle => _waitHandle;
        public FileStream fileLock { get; set; }

        public void Release()
        {
            try
            {
                fileLock.Dispose();
                fileLock = null;
                _waitHandle.Reset();
            }
            catch
            {
                // this is okay
            }
        }
    }

    /// <summary> Locks a file using flock on linux. This essentially works as a named mutex.  </summary>
    class PosixFileLock : IFileLock
    {
        int fileDescriptor;
        string fileName;
        private readonly ManualResetEvent _waitHandle;

        public PosixFileLock(string file)
        {
            this.fileName = file;
            // Open 'file' in read/write + append mode. If the file does not exist it will be created with the
            // most permissive access settings possible
            fileDescriptor =
                PosixNative.open(file, PosixNative.O_RDONLY | PosixNative.O_APPEND | PosixNative.O_CREAT, PosixNative.ALL_READ_WRITE);

            if (fileDescriptor == -1) throw new IOException($"Failed create file lock on {file}");
            _waitHandle = new ManualResetEvent(false);
        }

        /// <summary>
        /// Request an exclusive lock on the open file handle
        /// This call wil block until the lock is acquired
        /// </summary>
        private void Take()
        {
            PosixNative.flock(fileDescriptor, PosixNative.LOCK_EX);
        }

        public void Release()
        {
            if (fileDescriptor >= 0)
            {
                PosixNative.flock(fileDescriptor, PosixNative.LOCK_UN);
                _waitHandle.Reset();
            }
        }

        public void Dispose()
        {
            if (fileDescriptor >= 0 && _waitHandle.WaitOne(0))
            {
                Release();
            }

            PosixNative.close(fileDescriptor);
            fileDescriptor = -1;
            try 
            {
                File.Delete(this.fileName);
            }
            catch
            {
                // suppress
            }
        }

        public bool WaitOne()
        {
            Take();
            _waitHandle.Set();
            return true;
        }

        public bool WaitOne(TimeSpan timeout)
        {
            var sw = Stopwatch.StartNew();
            do
            {
                var @lock = PosixNative.flock(fileDescriptor, PosixNative.LOCK_NB | PosixNative.LOCK_EX);
                if (@lock == 0)
                {
                    _waitHandle.Set();
                    return true;
                }

                var remaining = timeout - sw.Elapsed;
                if (remaining.TotalMilliseconds > 1)
                    Thread.Sleep(1);
                else Thread.Yield();
            } while (sw.Elapsed < timeout);

            return false;
        }

        public bool WaitOne(int ms) => WaitOne(TimeSpan.FromMilliseconds(ms));
        public WaitHandle WaitHandle => _waitHandle;
    }

    class Win32FileLock : IFileLock
    {
        private Mutex _mutex;

        public Win32FileLock(string name)
        {
            // Having backslashes in the mutex name seems to cause issues for some reason. Replace them with slashes.
            _mutex = new Mutex(false, name.Replace("\\", "/") + "_opentap_named_mutex_");
        }

        public void Dispose()
        {
            try
            {
                if (_mutex?.WaitOne(0) == true)
                    _mutex?.ReleaseMutex();
            }
            catch (AbandonedMutexException)
            {
                // this is fine
            }

            _mutex?.Dispose();
            _mutex = null;
        }

        public bool WaitOne() => _mutex.WaitOne();
        public bool WaitOne(TimeSpan timeout) => _mutex.WaitOne(timeout);
        public bool WaitOne(int ms) => _mutex.WaitOne(ms);

        public WaitHandle WaitHandle => _mutex;
        public void Release() => _mutex.ReleaseMutex();
    }

    static class PosixNative
    {
        [DllImport("libc")]
        public static extern int open(string pathname, int flags, int mode);

        [DllImport("libc")]
        public static extern int close(int fd);

        [DllImport("libc")]
        public static extern int flock(int fd, int operation);

        public const int O_CREAT = 64; //00000100;
        public const int O_TRUNC = 512; //00001000;
        public const int O_APPEND = 1024; //00002000;

        public const int O_RDONLY = 0; //00000000;
        public const int O_RDWR = 2; //00000002;
        /// <summary>
        /// Place a shared lock. More than one process may hold a shared lock for a given file at a given time. 
        /// </summary>
        public const int LOCK_SH = 1;
        /// <summary>
        /// Place an exclusive lock. Only one process may hold an exclusive lock for a given file at a given time. 
        /// </summary>
        public const int LOCK_EX = 2;
        /// <summary>
        /// Return an error instead of blocking when the lock is taken
        /// </summary>
        public const int LOCK_NB = 4;
        /// <summary>
        /// Release the lock
        /// </summary>
        public const int LOCK_UN = 8;

        public const int S_IRUSR = 256; //00000400
        public const int S_IWUSR = 128; //00000200

        public const int S_IRGRP = 32; //00000040
        public const int S_IWGRP = 16; //00000020

        public const int S_IROTH = 4; //00000004
        public const int S_IWOTH = 2; //00000002

        public const int ALL_READ_WRITE = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
    }
}