using Google.Protobuf.WellKnownTypes;
using ServerCommon;
using ServerCommon.Cache;
using ServerCore; using ServerBase;

namespace GameServer
{
    //친구 요청에 관한 것만 여기 모은다. 

    public class SendFriendRequestAction : EntityActionBase
    {
        public SendFriendRequestAction(Player owner)
            : base(owner)
        {
        }

        public override async Task<Result> onInit()
        {
            var result = new Result();
            return await Task.FromResult(result);
        }

        public override void onClear()
        {
            return;
        }

        public async Task<Result> addRequestToCache(string nickname, string friendGuid)
        {
            var result = new Result();

            var owner = getOwner() as Player;
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
            var my_guid = owner.getUserGuid();

            //나한테 요청 보낼 수 없다. 
            if (friendGuid.Equals(my_guid))
            {
                var err_msg = $"Can't Send To Self myGuid = {my_guid} targetGuid : {friendGuid}, {toBasicString()}";
                result.setFail(ServerErrorCode.FriendRequestCantSendToSelf, err_msg);
                Log.getLogger().error(result.toBasicString());
                return result;
            }
            
            var friend_agent_action = owner.getEntityAction<FriendAgentAction>();

            //이미 친구인 경우
            result = friend_agent_action.raiseErrorIfExistFriend(friendGuid);
            if(result.isFail()) return result;


            //친구 맥스 초과
            result = friend_agent_action.friendMaxCountCheck();
            if (result.isFail()) return result;

            //'내가 차단한 유저라 보낼수 없다' 
            var block_action = owner.getEntityAction<BlockUserAgentAction>();
            if (true == block_action.isBlockUser(friendGuid))
            {
                var err_msg = $"Can't Send To Block User myGuid = {my_guid} targetGuid : {friendGuid}, {toBasicString()}";
                result.setFail(ServerErrorCode.FriendRequestCannotSendBlockUser, err_msg);
                Log.getLogger().error(result.toBasicString());
                return result;
            }

            var server_logic = GameServerApp.getServerLogic();
            var friend_request_cache = new FriendReqCacheRequest(owner, my_guid, friendGuid, server_logic.getRedisConnector());

            //이미 요청 보냈다
            var sended_reqs = await friend_request_cache.getSendedFriendRequests();
            (var is_sended, var req) = isSendedRequest(sended_reqs, friendGuid);
            if (true == is_sended)
            {
                //이미 요청 보낸것이므로 예외 처리
                string err_msg = $"requeat friend already send guid : {my_guid}, friend_guid : {friendGuid}, {toBasicString()}";
                result.setFail(ServerErrorCode.FriendRequestAlreadySend, err_msg);
                Log.getLogger().error(result.toBasicString());
                return result;
            }

            //이미 요청 받았다
            var received_reqs = await friend_request_cache.getReceivedFriendRequests();
            (var is_received, var _) = isReceivedRequest(received_reqs, friendGuid);
            if (true == is_received)
            {
                //이미 요청 받은것이므로 예외 처리
                string err_msg = $"requeat friend already receive guid : {my_guid}, friend_guid : {friendGuid}, {toBasicString()}";
                result.setFail(ServerErrorCode.FriendRequestAlreadyReceive, err_msg);
                Log.getLogger().error(result.toBasicString());
                return result;
            }

            //lock
            DateTime now = DateTime.UtcNow;
            IFriendInterlockAction interlock_action = new SendFriendRequestInterlockAction(owner, owner.getUserGuid(), friendGuid, now);
            result = await interlock_action.doInterlockAction();
            if(result.isFail()) return result;

            return result;
        }


        public (bool, FriendRequestCache?) isSendedRequest(List<FriendRequestCache> sended_reqs, string friendGuid)
        {
            foreach (var req in sended_reqs)
            {
                if (req.m_receiver_guid.Equals(friendGuid))
                {
                    return (true, req);
                }
            }
            return (false, null);
        }

        public (bool, FriendRequestCache?) isReceivedRequest(List<FriendRequestCache> received_reqs, string friendGuid)
        {
            foreach (var req in received_reqs)
            {
                if (req.m_sender_guid.Equals(friendGuid))
                {
                    return (true, req);
                }
            }
            return (false, null);
        }
    }
}