using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

public delegate void Callback<T>(T arg1);

/*
public class MessageManagerScript {

    public enum MessageType
    {
        ObjectPickedUp,
        ObjectDropped
    }

    private static Dictionary<MessageType, Delegate> eventTable = new Dictionary<MessageType, Delegate>();

    public static void AddListener(MessageType mType, Callback<T> handler)
    {
        Delegate d;
        if (eventTable.TryGetValue(mType, out d))
        {

        }
    }

    public static void RemoveListener(MessageType mType, Callback<T> handler)
    {

    }

    public static void BroadcastMessage(MessageType mType)
    {

    }

}
*/

public enum MessengerMode
{
    DONT_REQUIRE_LISTENER,
    REQUIRE_LISTENER,
}

public enum MessengerMessageType
{

    LogIntoFacebook,
    GetFacebookUsername,
    CheckFacebookLoginStarted,
    GetFacebookLoginStatus,
    ShowFacebookButton,
    HideFacebookButton,
    PostOnMyFacebookWall,
}

static internal class MessengerInternal
{
    static public Dictionary<MessengerMessageType, Delegate> eventTable = new Dictionary<MessengerMessageType, Delegate>();
    static public readonly MessengerMode DEFAULT_MODE = MessengerMode.REQUIRE_LISTENER;

    static public void OnListenerAdding(MessengerMessageType eventType, Delegate listenerBeingAdded)
    {
        if (!eventTable.ContainsKey(eventType))
        {
            eventTable.Add(eventType, null);
        }

        Delegate d = eventTable[eventType];
        if (d != null && d.GetType() != listenerBeingAdded.GetType())
        {
            throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", eventType, d.GetType().Name, listenerBeingAdded.GetType().Name));
        }
    }

    static public void OnListenerRemoving(MessengerMessageType eventType, Delegate listenerBeingRemoved)
    {
        if (eventTable.ContainsKey(eventType))
        {
            Delegate d = eventTable[eventType];

            if (d == null)
            {
                throw new ListenerException(string.Format("Attempting to remove listener with for event type {0} but current listener is null.", eventType));
            }
            else if (d.GetType() != listenerBeingRemoved.GetType())
            {
                throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being removed has type {2}", eventType, d.GetType().Name, listenerBeingRemoved.GetType().Name));
            }
        }
        else
        {
            throw new ListenerException(string.Format("Attempting to remove listener for type {0} but Messenger doesn't know about this event type.", eventType));
        }
    }

    static public void OnListenerRemoved(MessengerMessageType eventType)
    {
        if (eventTable[eventType] == null)
        {
            eventTable.Remove(eventType);
        }
    }

    static public void OnBroadcasting(MessengerMessageType eventType, MessengerMode mode)
    {
        if (mode == MessengerMode.REQUIRE_LISTENER && !eventTable.ContainsKey(eventType))
        {
            //throw new MessengerInternal.BroadcastException(string.Format("Broadcasting message {0} but no listener found.", eventType));
        }
    }

    static public BroadcastException CreateBroadcastSignatureException(MessengerMessageType eventType)
    {
        return new BroadcastException(string.Format("Broadcasting message {0} but listeners have a different signature than the broadcaster.", eventType));
    }

    public class BroadcastException : Exception
    {
        public BroadcastException(string msg)
            : base(msg)
        {
        }
    }

    public class ListenerException : Exception
    {
        public ListenerException(string msg)
            : base(msg)
        {
        }
    }
}


// One parameter
static public class Messenger<T>
{
    private static Dictionary<MessengerMessageType, Delegate> eventTable = MessengerInternal.eventTable;

    static public void AddListener(MessengerMessageType eventType, Callback<T> handler)
    {
        MessengerInternal.OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T>)eventTable[eventType] + handler;
    }

    static public void RemoveListener(MessengerMessageType eventType, Callback<T> handler)
    {
        MessengerInternal.OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T>)eventTable[eventType] - handler;
        MessengerInternal.OnListenerRemoved(eventType);
    }

    static public void Broadcast(MessengerMessageType eventType, T arg1)
    {
        Broadcast(eventType, arg1, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast(MessengerMessageType eventType, T arg1, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        Delegate d;
        if (eventTable.TryGetValue(eventType, out d))
        {
            Callback<T> callback = d as Callback<T>;
            if (callback != null)
            {
                callback(arg1);
            }
            else
            {
                throw MessengerInternal.CreateBroadcastSignatureException(eventType);
            }
        }
    }
}