using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;


using Newtonsoft.Json;


using ServerCore; using ServerBase;


using SESSION_ID = System.Int32;
using WORLD_ID = System.UInt32;
using META_ID = System.UInt32;
using ENTITY_GUID = System.String;
using ACCOUNT_ID = System.String;
using OWNER_GUID = System.String;
using USER_GUID = System.String;
using CHARACTER_GUID = System.String;
using ITEM_GUID = System.String;
using PARTY_GUID = System.String;
using System.Runtime.InteropServices;
using Amazon.S3.Model;



namespace ServerCommon
{
    public class UserAttribute : EntityAttributeBase, ICopyEntityAttributeFromDoc, ICopyEntityAttributeFromCache, IMergeWithEntityAttribute
    {
        [JsonProperty]
        public USER_GUID UserGuid { get; set; } = string.Empty;

        [JsonProperty]
        public ACCOUNT_ID AccountId { get; set; } = string.Empty;

        [JsonProperty]
        public string EOA { get; set; } = string.Empty;

        [JsonProperty]
        public CHARACTER_GUID SelectedCharacterGuid { get; set; } = string.Empty;

        [JsonProperty]
        public bool IsIntroCompleted { get; set; } = false;
        
        public PlayerStateType PlayerState { get; set; }

        public string OccupiedAnchorGuid {  get; set; } = string.Empty;

        public DateTime GameLoginDateTime = DateTime.MinValue;
        public DateTime GameLogoutDateTime = DateTime.MinValue;

        public UserAttribute(EntityBase owner)
            : base(owner)
        {
        }

        public bool applyUserGuidToRefAttributes( AccountBaseDoc accountBaseDoc, AccountAttribute accountAttribute
                                                , UserBaseDoc userBaseDoc )
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
            ArgumentNullReferenceCheckHelper.throwIfNull(accountBaseDoc, () => $"accountBaseDoc is null !!! - {owner.toBasicString()}");
            ArgumentNullReferenceCheckHelper.throwIfNull(accountAttribute, () => $"accountAttribute is null !!! - {owner.toBasicString()}");
            ArgumentNullReferenceCheckHelper.throwIfNull(userBaseDoc, () => $"userBaseDoc is null !!! - - {owner.toBasicString()}");

            accountAttribute.UserGuid = UserGuid;

            var account_doc_attrib = accountBaseDoc.getAttrib<AccountBaseAttrib>();
            NullReferenceCheckHelper.throwIfNull(account_doc_attrib, () => $"account_doc_attrib is null !!! - - {owner.toBasicString()}");

            account_doc_attrib.UserGuid = UserGuid;

            var user_doc_attrib = userBaseDoc.getAttrib<UserBaseAttrib>();
            NullReferenceCheckHelper.throwIfNull(user_doc_attrib, () => $"user_doc_attrib is null !!! - - {owner.toBasicString()}");

            user_doc_attrib.UserGuid = UserGuid;

            return true;
        }

        public override void onClear()
        {
            UserGuid = string.Empty;
            AccountId = string.Empty;
            EOA = string.Empty;
            UserGuid = string.Empty;
            IsIntroCompleted = false;
            PlayerState = PlayerStateType.None;
            OccupiedAnchorGuid = string.Empty;

            GameLoginDateTime = DateTime.MinValue;
            GameLogoutDateTime = DateTime.MinValue;

            getAttributeState().reset();
        }

        public override EntityAttributeBase onCloned()
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var cloned = new UserAttribute(owner);
            cloned.UserGuid = UserGuid;
            cloned.AccountId = AccountId;
            cloned.EOA = EOA;
            cloned.SelectedCharacterGuid = SelectedCharacterGuid;
            cloned.IsIntroCompleted = IsIntroCompleted;
            cloned.PlayerState = PlayerState;
            cloned.OccupiedAnchorGuid = OccupiedAnchorGuid;

            cloned.GameLoginDateTime = DateTime.MinValue;
            cloned.GameLogoutDateTime = DateTime.MinValue;

            return cloned;
        }

        public override IEntityAttributeTransactor onNewEntityAttributeTransactor()
        {
            return new UserAttributeTransactor(getOwner());
        }

        public Result onMerge(EntityAttributeBase otherEntityAttribute)
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var result = new Result();
            var err_msg = string.Empty;

            if (null == otherEntityAttribute)
            {
                err_msg = $"Invalid Param !!!, otherEntityAttribute is null - {owner.toBasicString()}";
                result.setFail(ServerErrorCode.FunctionParamNull, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            //=====================================================================================
            // OtherAttribute => Attribute
            //=====================================================================================
            var user_attribute = otherEntityAttribute as UserAttribute;
            if (null == user_attribute)
            {
                err_msg = $"Failed to cast UserAttribute !!!, user_attribute is null - {owner.toBasicString()}";
                result.setFail(ServerErrorCode.ClassTypeCastIsNull, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            UserGuid = user_attribute.UserGuid;
            AccountId = user_attribute.AccountId;
            EOA = user_attribute.EOA;
            SelectedCharacterGuid = user_attribute.SelectedCharacterGuid;
            IsIntroCompleted = user_attribute.IsIntroCompleted;
            PlayerState = user_attribute.PlayerState;
            OccupiedAnchorGuid = user_attribute.OccupiedAnchorGuid;

            GameLoginDateTime = user_attribute.GameLoginDateTime;
            GameLogoutDateTime = user_attribute.GameLogoutDateTime;

            //=====================================================================================
            // Attribute Try Pending Doc => Origin Doc
            //=====================================================================================
            var try_pending_doc = user_attribute.getTryPendingDocBase() as UserBaseDoc;
            if (null != try_pending_doc)
            {
                user_attribute.resetTryPendingDocBase();

                syncOriginDocBaseWithNewDoc<UserAttribute>(try_pending_doc);
            }

            var origin_doc_base = getOriginDocBase<UserAttribute>();
            if (null == origin_doc_base)
            {
                // DB 에 저장되어 있지 않는 경우 OriginDoc은 null 이다 !!!
                return result;
            }

            var user_base_attrib = origin_doc_base.getAttrib<UserBaseAttrib>();
            NullReferenceCheckHelper.throwIfNull(user_base_attrib, () => $"user_base_attrib is null !!! - {owner.toBasicString()}");

            user_base_attrib.UserGuid = UserGuid;
            user_base_attrib.AccountId = AccountId;
            user_base_attrib.EOA = EOA;
            user_base_attrib.SelectedCharacterGuid = SelectedCharacterGuid;
            user_base_attrib.IsIntroCompleted = IsIntroCompleted;

            user_base_attrib.GameLoginDateTime = GameLoginDateTime;
            user_base_attrib.GameLogoutDateTime = GameLogoutDateTime;

            return result;
        }

        public override UserBaseDoc onCreateDocBase()
        {
            return new UserBaseDoc(UserGuid);
        }

        public override async Task<(Result, DynamoDbDocBase?)> toDocBase(bool isForQuery = true)
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var result = new Result();

            //=====================================================================================
            // Attribute => try pending Doc
            //=====================================================================================
            var try_pending_doc = getTryPendingDocBase() as UserBaseDoc;
            if (null == try_pending_doc)
            {
                var to_copy_doc = onCreateDocBase();

                var origin_doc = getOriginDocBase<UserAttribute>();
                if (null != origin_doc)
                {
                    to_copy_doc.copyTimestampsFromOriginDocBase(origin_doc);
                }

                try_pending_doc = to_copy_doc;

                setTryPendingDocBase(try_pending_doc);
            }

            var to_copy_doc_attrib = try_pending_doc.getAttrib<UserBaseAttrib>();
            NullReferenceCheckHelper.throwIfNull(to_copy_doc_attrib, () => $"to_copy_doc_attrib is null !!! - {toBasicString()}");

            to_copy_doc_attrib.UserGuid = UserGuid;
            to_copy_doc_attrib.AccountId = AccountId;
            to_copy_doc_attrib.EOA = EOA;
            to_copy_doc_attrib.SelectedCharacterGuid = SelectedCharacterGuid;
            to_copy_doc_attrib.IsIntroCompleted = IsIntroCompleted;

            to_copy_doc_attrib.GameLoginDateTime = GameLoginDateTime;
            to_copy_doc_attrib.GameLogoutDateTime = GameLogoutDateTime;

            if (false == isForQuery)
            {
                return (result, try_pending_doc);
            }

            //=====================================================================================
            // Doc QueryType 반영
            //=====================================================================================
            (result, var to_query_doc) = await applyDoc4Query(try_pending_doc);
            if (result.isFail())
            {
                return (result, null);
            }

            return (result, to_query_doc);
        }

        public bool copyEntityAttributeFromCache(CacheBase? cacheBase)
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var err_msg = string.Empty;
            var login_cache = cacheBase as LoginCache;
            if(null == login_cache)
            {
                err_msg = $"Failed to copyEntityAttributeFromCache() !!!, login_cache is null :{nameof(LoginCache)} - {owner.toBasicString()}";
                Log.getLogger().error(err_msg);
                return false;
            }
            
            //=====================================================================================
            // Cache => Attribute
            //=====================================================================================
            PlayerState = login_cache.State;

            return true;
        }

        public bool copyEntityAttributeFromDoc(DynamoDbDocBase customDoc)
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var err_msg = string.Empty;

            bool is_success = false;

            var account_base_doc = customDoc as AccountBaseDoc;
            if (null != account_base_doc)
            {
                is_success = copyEntityAttributeFromAccountBaseDoc(account_base_doc);
            }

            var user_base_doc = customDoc as UserBaseDoc;
            if(null != user_base_doc)
            {
                is_success = copyEntityAttributeFromUserBaseDoc(user_base_doc);
            }

            if (false == is_success)
            {
                err_msg = $"Failed to copyEntityAttributeFromDoc() !!!, no successful data copies !!! :{toBasicString()} - {owner.toBasicString()}";
                Log.getLogger().error(err_msg);
                return false;
            }

            return true;
        }

        public bool copyEntityAttributeFromAccountBaseDoc(AccountBaseDoc? accountBaseDoc)
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var err_msg = string.Empty;

            var to_cast_string = typeof(AccountBaseDoc).Name;
            if (null == accountBaseDoc)
            {
                err_msg = $"Failed to copyEntityAttributeFromAccountBaseDoc() !!!, accountBaseDoc is null :{to_cast_string} - {owner.toBasicString()}";
                Log.getLogger().warn(err_msg);
                return false;
            }

            //=====================================================================================
            // Doc => Attribute
            //=====================================================================================
            var account_base_attrib = accountBaseDoc.getAttrib<AccountBaseAttrib>();
            NullReferenceCheckHelper.throwIfNull(account_base_attrib, () => $"account_base_attrib is null !!! - {owner.toBasicString()}");

            UserGuid = account_base_attrib.UserGuid;
            AccountId = account_base_attrib.AccountId;

            return true;
        }

        public bool copyEntityAttributeFromUserBaseDoc(UserBaseDoc? userBaseDoc)
        {
            var owner = getOwner();
            NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

            var err_msg = string.Empty;

            var to_cast_string = typeof(UserBaseDoc).Name;
            if (null == userBaseDoc)
            {
                err_msg = $"Failed to copyEntityAttributeFromUserBaseDoc() !!!, userBaseDoc is null :{to_cast_string} - {owner.toBasicString()}";
                Log.getLogger().warn(err_msg);
                return false;
            }

            //=====================================================================================
            // New Doc => Origin Doc
            //=====================================================================================
            syncOriginDocBaseWithNewDoc<UserAttribute>(userBaseDoc);

            //=====================================================================================
            // Doc => Attribute
            //=====================================================================================
            var user_base_attrib = userBaseDoc.getAttrib<UserBaseAttrib>();
            NullReferenceCheckHelper.throwIfNull(user_base_attrib, () => $"account_base_attrib is null !!! - {owner.toBasicString()}");

            UserGuid = user_base_attrib.UserGuid;
            AccountId = user_base_attrib.AccountId;
            EOA = user_base_attrib.EOA;
            SelectedCharacterGuid = user_base_attrib.SelectedCharacterGuid;
            IsIntroCompleted = user_base_attrib.IsIntroCompleted;

            return true;
        }

        public override string toBasicString()
        {
            return $"{GetType()}, UserGuid:{UserGuid}, SelectedCharacterGuid:{SelectedCharacterGuid}, AccountId:{AccountId}";
        }
    }

    public class UserAttributeTransactor : EntityAttributeTransactorBase<UserAttribute>, ICopyEntityAttributeTransactorFromEntityAttribute
    {
        public UserAttributeTransactor(EntityBase owner)
            : base(owner)
        {
        }

        public bool copyEntityAttributeTransactorFromEntityAttribute(EntityAttributeBase? entityAttributeBase)
        {
            var err_msg = string.Empty;

            var to_cast_string = typeof(UserAttribute).Name;

            var copy_from_user_attribute = entityAttributeBase as UserAttribute;
            if (null == copy_from_user_attribute)
            {
                err_msg = $"Failed to copyEntityAttributeTransactorFromEntityAttribute() !!!, copy_from_user_attribute is null :{to_cast_string}";
                Log.getLogger().error(err_msg);
                return false;
            }

            var copy_to_user_attribute = getClonedEntityAttribute() as UserAttribute;
            if (null == copy_to_user_attribute)
            {
                err_msg = $"Failed to copyEntityAttributeTransactorFromEntityAttribute() !!!, copy_to_user_attribute is null :{to_cast_string}";
                Log.getLogger().error(err_msg);
                return false;
            }

            copy_to_user_attribute.SelectedCharacterGuid = copy_from_user_attribute.SelectedCharacterGuid;
            copy_to_user_attribute.IsIntroCompleted = copy_from_user_attribute.IsIntroCompleted;
            copy_to_user_attribute.EOA = copy_from_user_attribute.EOA;
            copy_to_user_attribute.PlayerState = copy_from_user_attribute.PlayerState;
            copy_to_user_attribute.OccupiedAnchorGuid = copy_from_user_attribute.OccupiedAnchorGuid;

            return true;
        }
    }
}