package org.youngmonkeys.masterserver.admin.appender;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tvd12.ezyfox.bean.annotation.EzySingleton;
import org.youngmonkeys.ezyplatform.admin.appender.AdminDataAppender;
import org.youngmonkeys.ezyplatform.admin.service.AdminSettingService;
import org.youngmonkeys.masterserver.admin.service.GameMasterServerSettingService;

import java.io.File;
import java.util.List;

@EzySingleton
public class AdminSocketSslKeystoreReloadAppender
    extends AdminDataAppender<Void, Void, Void> {

    private final GameMasterServerSettingService masterServerSettingService;

    public AdminSocketSslKeystoreReloadAppender(
        ObjectMapper mapper,
        AdminSettingService settingService,
        GameMasterServerSettingService masterServerSettingService
    ) {
        super(mapper, settingService);
        this.masterServerSettingService = masterServerSettingService;
    }

    @Override
    protected boolean defaultStarted() {
        return true;
    }

    @Override
    protected void doAppend() {
        File cert = new File(masterServerSettingService.getFullChainPath());
        if (!cert.exists()) {
            return;
        }
        long currentLastModified = cert.lastModified();
        long previousLastModified = masterServerSettingService.getFullChainLastModified();
        if (currentLastModified > previousLastModified) {
            logger.info("Cert file has been updated");
            masterServerSettingService.saveFullChainLastModified(currentLastModified);
        }
    }

    @Override
    protected String getAppenderNamePrefix() {
        return "socket_ssl_keystore_reload_appender";
    }

    @Override
    protected Void defaultPageToken() {
        throw new UnsupportedOperationException();
    }

    @Override
    protected Class<Void> pageTokenType() {
        throw new UnsupportedOperationException();
    }

    @Override
    protected Void extractNewLastPageToken(List<Void> v, Void p) {
        throw new UnsupportedOperationException();
    }

    @Override
    protected List<Void> getValueList(Void p) {
        throw new UnsupportedOperationException();
    }
}

@DoGet("/{port}")
    public AdminInstanceResponse portGet(
        @PathVariable int port,
        @RequestParam(value = "apiKey") String apiKey,
        @RequestParam(
            value = "activeFullChainLastModified",
            defaultValue = "0"
        ) long activeFullChainLastModified
    ) {
        apiKeyValidator.validate(apiKey);
        return instanceControllerService.getInstance(
            port,
            activeFullChainLastModified
        );
    }

package org.youngmonkeys.masterserver.admin.response;

import lombok.Getter;
import lombok.experimental.SuperBuilder;
import org.youngmonkeys.masterserver.response.InstanceResponse;

@Getter
@SuperBuilder
public class AdminInstanceResponse extends InstanceResponse {
    private int playerCount;
    private long createdAt;
    private long updatedAt;
    private long sslFullChainLastModified;
    private String sslFullChain;                             // null nếu không có thay đổi gì
    private String sslPrivateKey;
}

using System;
using Unity.Entities;
using Unity.NetCode;
using Unity.Networking.Transport;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Youngmonkeys.EzyTank
{
	public class ServerNetworkStreamDriverEntryPresenter : AbstractNetworkStreamDriverEntry<ServerNetworkStreamDriverEntryPresenter>
	{
		public void Start()
		{
			if (InstanceManager.Instance.FullChain.Equals(""))
			{
				return;    // Không tiếp tục nếu chưa có thông tin FullChain
			}
			if (ClientServerBootstrap.RequestedPlayType == ClientServerBootstrap.PlayType.Server)
			{
				var oldConstructor = NetworkStreamReceiveSystem.DriverConstructor;
				try
				{
					NetworkStreamReceiveSystem.DriverConstructor = new IcpUdpWsNetworkDriverConstructor();
					var server = ClientServerBootstrap.CreateServerWorld("ServerWorld");
					string commandPort = EzyTankCommandLineUtils.GetPort();
					Debug.Log($"CommandPort = {commandPort}");
					NetworkEndpoint ep = NetworkEndpoint.AnyIpv4.WithPort(Convert.ToUInt16(commandPort));
					{
						using EntityQuery drvQuery = server.EntityManager.CreateEntityQuery(ComponentType.ReadWrite<NetworkStreamDriver>());
						drvQuery.GetSingletonRW<NetworkStreamDriver>().ValueRW.RequireConnectionApproval = true;
						drvQuery.GetSingletonRW<NetworkStreamDriver>().ValueRW.Listen(ep);
					}
					DestroyLocalSimulationWorld();
					World.DefaultGameObjectInjectionWorld ??= server;

					SceneManager.LoadSceneAsync("ServerLoungeScene", LoadSceneMode.Single);
				}
				finally
				{
					NetworkStreamReceiveSystem.DriverConstructor = oldConstructor;
				}
			}
		}
	}
}

public class InstanceManager : SingletonMonoBehaviour<InstanceManager>
	{
		...

		private void Update()
		{
			if (ClientServerBootstrap.RequestedPlayType == ClientServerBootstrap.PlayType.Client)
			{
				return;
			}
			mTimerInSeconds -= Time.deltaTime;
			if (mTimerInSeconds > 0)
			{
				return;
			}
			mTimerInSeconds = timerMaxInSeconds;
			string url = HttpUtils.ToGameMasterServerApiUrl(
				$"/instances/{mCommandPort}?apiKey={mCommandApiKey}&activeFullChainLastModified={mActiveFullChainLastModified}",
				true
			);
			HttpGetRequest getRequest = new HttpGetRequest(url);

			HttpClient.Instance.SendHttpRequest<HttpGetRequest, InstanceModel>(
				getRequest,
				HandleGetInstanceResponse,
				HandleGetInstanceError
			);
		}

                ...

		private void HandleGetInstanceResponse(InstanceModel instance)
		{
			if (instance.Status == "SHUTTING_DOWN")
			{
				string url = HttpUtils.ToGameMasterServerApiUrl($"/instances/{mCommandPort}?apiKey={mCommandApiKey}", true);
				HttpDeleteRequest deleteRequest = new HttpDeleteRequest(url);
				HttpClient.Instance.SendHttpRequest<HttpDeleteRequest, NoContentResponse>(
					deleteRequest,
					QuitApplication,
					HandleDeleteInstanceError
				);
			}
			if (instance.SslFullChain != null)               // Có thông tin mới về certificate
			{
				mActiveFullChainLastModified = instance.SslFullChainLastModified;
				mFullChain = instance.SslFullChain;
				mPrivateKey = instance.SslPrivateKey;
				ServerNetworkRestartManager.Instance.RequestServerNetworkRestart();
			}
		}
                ...
	}