/***
  This file is part of avahi.

  avahi is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.

  avahi 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 Lesser General
  Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with avahi; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA.
***/


using System;
using System.Threading;
using System.Collections;
using System.Runtime.InteropServices;
using Mono.Unix;
using Mono.Unix.Native;

using Stdlib = Mono.Unix.Native.Stdlib;

namespace Avahi
{
    internal enum ResolverEvent {
        Found,
        Failure
    }

    internal enum BrowserEvent {
        Added,
        Removed,
        CacheExhausted,
        AllForNow,
        Failure
    }

    internal delegate int PollCallback (IntPtr ufds, uint nfds, int timeout);
    internal delegate void ClientCallback (IntPtr client, ClientState state, IntPtr userData);

    public delegate void ClientStateHandler (object o, ClientStateArgs state);

    public class ClientStateArgs : EventArgs
    {
        private ClientState state;
        private ErrorCode error;

        public ClientState State
        {
            get { return state; }
        }

        public ErrorCode Error
        {
            get { return error; }
        }

        public ClientStateArgs (ClientState state, ErrorCode error)
        {
            this.state = state;
            this.error = error;
        }
    }

    public enum Protocol {
        Unspecified = -1,
        IPv4 = 0,
        IPv6 = 1
    }

    internal enum ServerState {
        Invalid,
        Registering,
        Running,
        Collision
    }

    public enum ClientState {
        Registering = ServerState.Registering,
        Running = ServerState.Running,
        Collision = ServerState.Collision,
        Failure = 100,
        Connecting = 101
    }

    [Flags]
    public enum LookupFlags {
        None = 0,
        UseWideArea = 1,
        UseMulticast = 2,
	NoTxt = 4,
        NoAddress = 8
    }

    [Flags]
    public enum LookupResultFlags {
        None = 0,
        Cached = 1,
        WideArea = 2,
        Multicast = 4,
        Local = 8,
        OurOwn = 16,
    }

    [Flags]
    public enum ClientFlags {
        None = 0,
        IgnoreUserConfig = 1,
        NoFail = 2
    }

    public class Client : IDisposable
    {
        private IntPtr handle;
        private ClientCallback cb;
        private PollCallback pollcb;
        private IntPtr spoll;

        private Thread thread;

        [DllImport ("avahi-client")]
        private static extern IntPtr avahi_client_new (IntPtr poll, ClientFlags flags, ClientCallback handler,
                                                       IntPtr userData, out int error);

        [DllImport ("avahi-client")]
        private static extern void avahi_client_free (IntPtr handle);

        [DllImport ("avahi-client")]
        private static extern IntPtr avahi_client_get_version_string (IntPtr handle);

        [DllImport ("avahi-client")]
        private static extern IntPtr avahi_client_get_host_name (IntPtr handle);

        [DllImport ("avahi-client")]
        private static extern IntPtr avahi_client_get_domain_name (IntPtr handle);

        [DllImport ("avahi-client")]
        private static extern IntPtr avahi_client_get_host_name_fqdn (IntPtr handle);

        [DllImport ("avahi-client")]
        private static extern ClientState avahi_client_get_state (IntPtr handle);

        [DllImport ("avahi-client")]
        private static extern int avahi_client_errno (IntPtr handle);

        [DllImport ("avahi-common")]
        private static extern IntPtr avahi_simple_poll_new ();

        [DllImport ("avahi-common")]
        private static extern IntPtr avahi_simple_poll_get (IntPtr spoll);

        [DllImport ("avahi-common")]
        private static extern void avahi_simple_poll_free (IntPtr spoll);

        [DllImport ("avahi-common")]
        private static extern int avahi_simple_poll_loop (IntPtr spoll);

        [DllImport ("avahi-common")]
        private static extern void avahi_simple_poll_set_func (IntPtr spoll, PollCallback cb);

        [DllImport ("avahi-common")]
        private static extern void avahi_simple_poll_quit (IntPtr spoll);

        [DllImport ("avahi-client")]
        private static extern uint avahi_client_get_local_service_cookie (IntPtr client);

        [DllImport ("avahi-common")]
        private static extern int avahi_service_name_join (IntPtr buf, int len, byte[] name, byte[] type,
                                                           byte[] domain);

        [DllImport ("avahi-common")]
        private static extern int avahi_service_name_split (byte[] service, IntPtr name, int name_len,
                                                            IntPtr type, int type_len,
                                                            IntPtr domain, int domain_len);


        [DllImport ("libc")]
        private static extern int poll(IntPtr ufds, uint nfds, int timeout);

        public event ClientStateHandler StateChanged;

        internal IntPtr Handle
        {
            get { return handle; }
        }

        public string Version
        {
            get {
                lock (this) {
                    return Utility.PtrToString (avahi_client_get_version_string (handle));
                }
            }
        }

        public string HostName
        {
            get {
                lock (this) {
                    return Utility.PtrToString (avahi_client_get_host_name (handle));
                }
            }
        }

        public string DomainName
        {
            get {
                lock (this) {
                    return Utility.PtrToString (avahi_client_get_domain_name (handle));
                }
            }
        }

        public string HostNameFqdn
        {
            get {
                lock (this) {
                    return Utility.PtrToString (avahi_client_get_host_name_fqdn (handle));
                }
            }
        }

        public ClientState State
        {
            get {
                lock (this) {
                    return (ClientState) avahi_client_get_state (handle);
                }
            }
        }

        public uint LocalServiceCookie
        {
            get {
                lock (this) {
                    return avahi_client_get_local_service_cookie (handle);
                }
            }
        }

        internal ErrorCode LastError
        {
            get {
                lock (this) {
                    return (ErrorCode) avahi_client_errno (handle);
                }
            }
        }

        public Client (ClientFlags flags)
        {
            spoll = avahi_simple_poll_new ();

            pollcb = OnPollCallback;
            avahi_simple_poll_set_func (spoll, pollcb);
            IntPtr poll = avahi_simple_poll_get (spoll);
            cb = OnClientCallback;

            int error;
            handle = avahi_client_new (poll, flags, cb, IntPtr.Zero, out error);
            if (error != 0)
                throw new ClientException (error);

            thread = new Thread (PollLoop);
            thread.IsBackground = true;
            thread.Start ();
        }

        public Client () : this (ClientFlags.None) {
        }

        ~Client ()
        {
            Dispose ();
        }

        public void Dispose ()
        {
            if (handle != IntPtr.Zero) {
                lock (this) {
                    avahi_client_free (handle);
                    handle = IntPtr.Zero;

                    avahi_simple_poll_quit (spoll);
                    Monitor.Wait (this);

                    avahi_simple_poll_free (spoll);
                }
            }
        }

        public static string JoinServiceName (string name, string type, string domain)
        {
            int len = 4 * (name.Length + type.Length + domain.Length) + 4;
            IntPtr buf = Stdlib.malloc ((ulong) len);

            int ret = avahi_service_name_join (buf, len,
                                               Utility.StringToBytes (name),
                                               Utility.StringToBytes (type),
                                               Utility.StringToBytes (domain));

            if (ret < 0) {
                Utility.Free (buf);
                return null; // FIXME, should throw exception
            }

            string service = Utility.PtrToString (buf);
            Utility.Free (buf);

            return service;
        }

        public static void SplitServiceName (string service, out string name, out string type, out string domain)
        {
            int len = 1024;

            IntPtr namePtr = Stdlib.malloc ((ulong) len);
            IntPtr typePtr = Stdlib.malloc ((ulong) len);
            IntPtr domainPtr = Stdlib.malloc ((ulong) len);

            int ret = avahi_service_name_split (Utility.StringToBytes (service), namePtr, len, typePtr, len,
                                                domainPtr, len);

            if (ret < 0) {
                Utility.Free (namePtr);
                Utility.Free (typePtr);
                Utility.Free (domainPtr);

                name = null;
                type = null;
                domain = null;
                return;
            }

            name = Utility.PtrToString (namePtr);
            type = Utility.PtrToString (typePtr);
            domain = Utility.PtrToString (domainPtr);

            Utility.Free (namePtr);
            Utility.Free (typePtr);
            Utility.Free (domainPtr);
        }

        internal void ThrowError ()
        {
            ErrorCode error = LastError;

            if (error != ErrorCode.Ok)
                throw new ClientException (error);
        }

        private void OnClientCallback (IntPtr client, ClientState state, IntPtr userData)
        {
            if (StateChanged != null)
                StateChanged (this, new ClientStateArgs (state, LastError));
        }

        private int OnPollCallback (IntPtr ufds, uint nfds, int timeout) {
            Monitor.Exit (this);
            int result = poll (ufds, nfds, timeout);
            Monitor.Enter (this);
            return result;
        }

        private void PollLoop () {
            try {
                lock (this) {
                    avahi_simple_poll_loop (spoll);
                    Monitor.Pulse (this);
                }
            } catch (Exception e) {
                Console.Error.WriteLine ("Error in avahi-sharp event loop: " + e);
            }
        }
    }
}