using PhotonWire.Server;

namespace GettingStarted.Server
{
    // Application Entrypoint for Photon Server.
    public class Startup : PhotonWireApplicationBase
    {

    }
}

using PhotonWire.Server;

namespace GettingStarted.Server
{
    [Hub(0)]
    public class MyFirstHub : Hub
    {
        [Operation(0)]
        public int Sum(int x, int y)
        {
            return x + y;
        }
    }
}

using ExitGames.Client.Photon;
using PhotonWire.Client;
using UniRx;
using UnityEngine;
using UnityEngine.UI;

namespace GettingStarted.Client
{
    public class PhotonButton : MonoBehaviour
    {
        // set from inspector
        public Button button;

        ObservablePhotonPeer peer;
        MyFirstHubProxy proxy;

        void Start()
        {
            // Create Photon Connection
            peer = new ObservablePhotonPeer(ConnectionProtocol.Tcp, peerName: "PhotonTest");

            // Create typed server rpc proxy
            proxy = peer.CreateTypedHub<MyFirstHubProxy>();

            // Async Connect(return IObservable)
            peer.ConnectAsync("127.0.0.1:4530", "GettingStarted.Server")
                .Subscribe(x =>
                {
                    UnityEngine.Debug.Log("IsConnected?" + x);
                });


            button.OnClickAsObservable().Subscribe(_ =>
            {

                // Invoke.Method calls server method and receive result.
                proxy.Invoke.SumAsync(100, 300)
                    .Subscribe(x => Debug.Log("Server Return:" + x));

            });
        }

        void OnDestroy()
        {
            // disconnect peer.
            peer.Dispose();
        }
    }

}

namespace GettingStarted.Share
{
    public class Person
    {
        public int Age { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

[Operation(1)]
public Person CreatePerson(int seed)
{
    var rand = new Random(seed);

    return new Person
    {
        FirstName = "Yoshifumi",
        LastName = "Kawai",
        Age = rand.Next(0, 100)
    };
}

// Unity Button Click
proxy.Invoke.CreatePersonAsync(Random.Range(0, 100))
    .Subscribe(x =>
    {
        UnityEngine.Debug.Log(x.FirstName + " " + x.LastName + " Age:" + x.Age);
    });

[System.CodeDom.Compiler.GeneratedCodeAttribute("MsgPack.Serialization.CodeDomSerializers.CodeDomSerializerBuilder", "0.6.0.0")]
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public class GettingStarted_Share_PersonSerializer : MsgPack.Serialization.MessagePackSerializer<GettingStarted.Share.Person> {
        
    private MsgPack.Serialization.MessagePackSerializer<int> _serializer0;
        
    private MsgPack.Serialization.MessagePackSerializer<string> _serializer1;
        
    public GettingStarted_Share_PersonSerializer(MsgPack.Serialization.SerializationContext context) : 
            base(context) {
        MsgPack.Serialization.PolymorphismSchema schema0 = default(MsgPack.Serialization.PolymorphismSchema);
        schema0 = null;
        this._serializer0 = context.GetSerializer<int>(schema0);
        MsgPack.Serialization.PolymorphismSchema schema1 = default(MsgPack.Serialization.PolymorphismSchema);
        schema1 = null;
        this._serializer1 = context.GetSerializer<string>(schema1);
    }
        
    protected override void PackToCore(MsgPack.Packer packer, GettingStarted.Share.Person objectTree) {
        packer.PackArrayHeader(3);
        this._serializer0.PackTo(packer, objectTree.Age);
        this._serializer1.PackTo(packer, objectTree.FirstName);
        this._serializer1.PackTo(packer, objectTree.LastName);
    }
        
    protected override GettingStarted.Share.Person UnpackFromCore(MsgPack.Unpacker unpacker) {
        GettingStarted.Share.Person result = default(GettingStarted.Share.Person);
        result = new GettingStarted.Share.Person();
        
        int unpacked = default(int);
        int itemsCount = default(int);
        itemsCount = MsgPack.Serialization.UnpackHelpers.GetItemsCount(unpacker);
        System.Nullable<int> nullable = default(System.Nullable<int>);
        if ((unpacked < itemsCount)) {
            nullable = MsgPack.Serialization.UnpackHelpers.UnpackNullableInt32Value(unpacker, typeof(GettingStarted.Share.Person), "Int32 Age");
        }
        if (nullable.HasValue) {
            result.Age = nullable.Value;
        }
        unpacked = (unpacked + 1);
        string nullable0 = default(string);
        if ((unpacked < itemsCount)) {
            nullable0 = MsgPack.Serialization.UnpackHelpers.UnpackStringValue(unpacker, typeof(GettingStarted.Share.Person), "System.String FirstName");
        }
        if (((nullable0 == null) 
                    == false)) {
            result.FirstName = nullable0;
        }
        unpacked = (unpacked + 1);
        string nullable1 = default(string);
        if ((unpacked < itemsCount)) {
            nullable1 = MsgPack.Serialization.UnpackHelpers.UnpackStringValue(unpacker, typeof(GettingStarted.Share.Person), "System.String LastName");
        }
        if (((nullable1 == null) 
                    == false)) {
            result.LastName = nullable1;
        }
        unpacked = (unpacked + 1);
        
        return result;
    }
}

public class Startup : PhotonWireApplicationBase
{
    // When throw exception, returns exception information.
    public override bool IsDebugMode
    {
        get
        {
            return true;
        }
    }

    // connected peer is server to server? 
    protected override bool IsServerToServerPeer(InitRequest initRequest)
    {
        return (initRequest.ApplicationId == "MyMaster");
    }

    // initialize, if needs server to server connection, write here.
    protected override void SetupCore()
    {
        var _ = ConnectToOutboundServerAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 4530), "MyMaster");
    }

    // tear down
    protected override void TearDownCore()
    {
        base.TearDownCore();
    }
}

// define client interface.
public interface ITutorialClient
{
    [Operation(0)]
    void GroupBroadcastMessage(string message);
}

// Hub<TClient>
[Hub(100)]
public class Tutorial : PhotonWire.Server.Hub<ITutorialClient>
{
    [Operation(2)]
    public void BroadcastAll(string message)
    {
        // Get ClientProxy from Clients property, choose target and Invoke.
        this.Clients.All.GroupBroadcastMessage(message);
    }
}

this.Context.Peer.RegisterDisconnectAction((reasonCode, readonDetail) =>
{
    // do when disconnected.
});

[Operation(3)]
public void RegisterGroup(string groupName)
{
    // Group is registered by per connection(peer)
    this.Context.Peer.AddGroup(groupName);
}

[Operation(4)]
public void BroadcastTo(string groupName, string message)
{
    // Get ITutorialClient -> Invoke method
    this.Clients.Group(groupName).GroupBroadcastMessage(message);
}

[Operation(1)]
public async Task<string> GetHtml(string url)
{
    var httpClient = new HttpClient();
    var result = await httpClient.GetStringAsync(url);

    // Photon's String deserialize size limitation
    var cut = result.Substring(0, Math.Min(result.Length, short.MaxValue - 5000));

    return cut;
}

// 1. Inherit ServerHub
// 2. Add HubAttribute
[Hub(54)]
public class MasterTutorial : PhotonWire.Server.ServerToServer.ServerHub
{
    // 3. Create virtual, async method
    // 4. Add OperationAttribute
    [Operation(0)]
    public virtual async Task<int> Multiply(int x, int y)
    {
        return x * y;
    }
}

[Operation(5)]
public async Task<int> ServerToServer(int x, int y)
{
    var mul = await GetServerHubProxy<MasterTutorial>().Single.Multiply(x, y);
    
    // If is not in Hub, You can get ClientProxy from global PeerManager
    // PeerManager.GetServerHubContext<MasterTutorial>().Clients.Single.Multiply(x, y);
    
    return mul;
}

[Hub(10)]
public class BroadcasterReceiveServerHub : ReceiveServerHub
{
    [Operation(20)]
    public virtual async Task Broadcast(string group, string msg)
    {
        // Send to clients.
        this.GetClientsProxy<Tutorial, ITutorialClient>()
            .Group(group)
            .GroupBroadcastMessage(msg);
    }
}

[Operation(1)]
public virtual async Task Broadcast(string group, string message)
{
    // Invoke all receive server hubs
    await GetReceiveServerHubProxy<BroadcasterReceiveServerHub>()
        .All.Invoke(x => x.Broadcast(group, message));
}

// receive per operation
proxy.Receive.GroupBroadcastMessage.Subscribe();

// or receive per client 
proxy.RegisterListener(/* TutorialProxy.ITutorialClient */);

public class Startup : PhotonWireApplicationBase
{
    protected override bool IsServerToServerPeer(InitRequest initRequest)
    {
        return (initRequest.ApplicationId == "MyMaster");
    }

    protected override void SetupCore()
    {
        var _ = ConnectToOutboundServerAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 4530), "MyMaster");
    }
}

public class GameServerStartup : PhotonWire.Server.PhotonWireApplicationBase
{
    // Only Enables GameServer Hub.
    protected override string[] HubTargetTags
    {
        get
        {
            return new[] { "GameServer" };
        }
    }

    protected override void SetupCore()
    {
        // Load from Configuration file.
        foreach (var item in PhotonWire.Server.Configuration.PhotonWireConfigurationSection.GetSection().GetConnectionList())
        {
            var ip = new IPEndPoint(IPAddress.Parse(item.IPAddress), item.Port);
            var _ = ConnectToOutboundServerAsync(ip, item.ApplicationName);
        }
    }
}

public class TestFilter : PhotonWireFilterAttribute
{
    public override async Task<object> Invoke(OperationContext context, Func<Task<object>> next)
    {
        var path = context.Hub.HubName + "/" + context.Method.MethodName;
        try
        {
            Debug.WriteLine("Before:" + path + " - " + context.Peer.PeerKind);
            var result = await next();
            Debug.WriteLine("After:" + path);
            return result;
        }
        catch (Exception ex)
        {
            Debug.WriteLine("Ex " + path + " :" + ex.ToString());
            throw;
        }
        finally
        {
            Debug.WriteLine("Finally:" + path);
        }
    }
}

[Hub(3)]
public class MasterTest : ServerHub
{
    [TestFilter] // use filter
    [Operation(5)]
    public virtual async Task<string> EchoAsync(string msg)
    {
        return msg;
    }
}

// Server
[Operation(0)]
public void ServerError()
{
    throw new CustomErrorException { ErrorMessage = "Custom Error" }; 
}

// Client
proxy.Invoke.ServerError()
    .Catch((CustomErrorException ex) =>
    {
        UnityEngine.Debug.Log(ex.ErrorMessage);
    })
    .Subscribe();

ObservableEventListener.FromTraceEvent("PhotonWire").DumpWithColor();