﻿using UnityEngine;
using Stove.StoveSDK;
using System.Collections;
using System.Collections.Generic;
using MiniJSON;
using System;

public class LogSample : MonoBehaviour
{
    void Start()
    {
    }

    void Update()
    {
    }

    public void AddEvent()
    {
        LogDialog.Show((string name, string category1, string category2, string simpleValue, string parameters) =>
        {
            if (name == null &&
                 category1 == null &&
                 category2 == null &&
                 simpleValue == null &&
                 parameters == null)
            {
                // cancel
            }
            else
            {

                LogEvent logEvent = new LogEvent(name);

                if (!string.IsNullOrEmpty(category1))
                {
                    logEvent.Category1 = category1;
                }

                if (!string.IsNullOrEmpty(category2))
                {
                    logEvent.Category2 = category2;
                }

                if (!string.IsNullOrEmpty(simpleValue))
                {
                    logEvent.SimpleValue = float.Parse(simpleValue);
                }

                if (!string.IsNullOrEmpty(parameters))
                {
                    logEvent.Parameters = Json.Deserialize(parameters) as Dictionary<string, string>;
                }

                Debug.Log("------- [Stove-Sample] Log.Add -------");

                Log.Add(logEvent, (Result result) =>
                {
                    Debug.Log("------- [Stove-Sample] Log.Add : " + result + " -------");

                    if (result.IsSuccessful)
                    {
                        SSTools.ShowMessage("Log.Add Success", SSTools.Position.bottom, SSTools.Time.oneSecond);
                    }
                    else
                    {
                        SSTools.ShowMessage("Log.Add Fail", SSTools.Position.bottom, SSTools.Time.oneSecond);
                    }
                });
            }
        });
    }

    public void Flush()
    {
        Log.Flush();

        Debug.Log("------- [Stove-Sample] Log.Flush -------");
    }

    public void AddEvent50()
    {
        for (int i = 0; i < 50; i++)
        {
            LogEvent logEvent = new LogEvent("AddEvent50 : " + i);

            Debug.Log("------- [Stove-Sample] Log.AddEvent50 start : " + i + " -------");

            Log.Add(logEvent, (Result result) =>
            {
                Debug.Log("------- [Stove-Sample] Log.AddEvent50 end : " + i + " -------");

                if (result.IsSuccessful)
                {
                    SSTools.ShowMessage("Log.Add Success", SSTools.Position.bottom, SSTools.Time.oneSecond);
                }
                else
                {
                    SSTools.ShowMessage("Log.Add Fail", SSTools.Position.bottom, SSTools.Time.oneSecond);
                }
            });
        }
    }

    public void AddEventCustom()
    {
        TextFieldOneDialog.Show((string count) =>
        {
            if (count != null)
            {
                int convertCount = Convert.ToInt32(count);
                for (int i = 0; i < convertCount; i++)
                {
                    LogEvent logEvent = new LogEvent("AddEvent" + convertCount + " : " + i);

                    Debug.Log("------- [Stove-Sample] Log.AddEvent" + convertCount + "start : " + i + " -------");

                    Log.Add(logEvent, (Result result) =>
                    {
                        Debug.Log("------- [Stove-Sample] Log.AddEvent" + convertCount + "end : " + i + " -------");

                        if (result.IsSuccessful)
                        {
                            SSTools.ShowMessage("Log.Add Success", SSTools.Position.bottom, SSTools.Time.oneSecond);
                        }
                        else
                        {
                            SSTools.ShowMessage("Log.Add Fail", SSTools.Position.bottom, SSTools.Time.oneSecond);
                        }
                    });
                }
            }
        });
    }

    public void Version()
    {
        SSTools.ShowMessage("Log Version : " + Log.GetVersion(), SSTools.Position.bottom, SSTools.Time.oneSecond);
    }

    public void Versions()
    {
        SSTools.ShowMessage("Log Versions : " + Log.GetSDKVersions(), SSTools.Position.bottom, SSTools.Time.oneSecond);
    }

    // 게임이 아는 externalId 값. Log 과 GameLog 는 별도로 운영되는 모듈이라 값이 공유되지 않으므로,
    // 동일 값을 두 API(Log.SetExternalId / GameLog.Configure)에 각각 주입한다.
    private static string cachedExternalId;

    public void SetExternalId()
    {
        TextFieldOneDialog.Show((string externalId) =>
        {
            if (externalId != null)
            {
                Debug.Log("------- [Stove-Sample] Log.SetExternalId : " + externalId + " -------");
                
                Log.SetExternalId(externalId);
                // Log 과 GameLog 는 별도 모듈이라 값이 공유되지 않는다. 게임이 아는 동일 externalId 를
                // GameLog.Configure 에도 주입하기 위해 캐시한다(ConfigureGameLog 에서 사용).
                cachedExternalId = externalId;
                
                SSTools.ShowMessage("Log.SetExternalId Success: " + externalId, SSTools.Position.bottom, SSTools.Time.oneSecond);
            }
        });
    }

    // Call once when Auth.Initialize completes (see AuthSample). GameLog.Configure must
    // run before any GameLog.Add. static so the auth flow can trigger it without a LogSample instance.
    //
    // 파라미터는 하드코딩이 아니라 Auth.Initialize 후 서버에서 조회된 설정값(Constants)에서 가져온다.
    // (native GameLogHelper.configure 와 동일한 소스)
    public static void ConfigureGameLog()
    {
        string serviceId = Constants.Get("service_id");
        // 기존 GameLogSender 와 동일: {endpoint}/{service_id} 완성형 URL
        string endpoint = Constants.Get("game_log_endpoint");
        string serverUrl = endpoint + "/" + serviceId;
        string marketGameId = Constants.Get("market_game_id");
        string environment = Constants.Get("environment");
        string ip = Constants.Get("ip_address");
        string language = GetLanguageCode();

        Dictionary<string, object> gds = ParseGds(Constants.Get("gds"));
        int batchSize = ParseBatchSize(Constants.Get("game_log_batch_size"));

        // session_id 는 주입하지 않는다 — 모듈이 내부에서 자체 생성.
        GameLog.Configure(
            serverUrl: serverUrl,
            serviceId: serviceId,
            marketGameId: marketGameId,
            environment: string.IsNullOrEmpty(environment) ? "live" : environment,
            batchSize: batchSize,
            ip: ip,
            gds: gds,
            language: string.IsNullOrEmpty(language) ? "ko" : language,
            // Log 과 GameLog 는 별도 모듈이라 값이 공유되지 않는다. 게임이 아는 externalId 를
            // Log.SetExternalId 와 동일하게 GameLog 에도 주입한다(SetExternalId 시 캐시한 값).
            externalId: cachedExternalId,
            // 로그 생성 시점마다 lazy 호출 → 최신 유저 정보(Auth.AccessToken.User). 미로그인 시 null → guid "0".
            // 주의: resolver 는 모듈 백그라운드 스레드에서 호출된다. 게임에서는 스레드 안전한 접근을
            //       보장해야 한다(예: 로그인 시 메인 스레드에서 값 캐시). 샘플은 native 와 동일하게 직접 조회.
            userInfoResolver: () =>
            {
                AccessToken token = Auth.AccessToken;
                if (token == null || token.User == null)
                {
                    return null;
                }
                User user = token.User;
                GameProfile gameProfile = user.GameProfile;
                GameLogUserInfo info = new GameLogUserInfo();
                info.UserId = user.UserId;
                if (gameProfile != null)
                {
                    if (gameProfile.CharacterNumber > 0)
                    {
                        info.CharacterNo = gameProfile.CharacterNumber;
                    }
                    if (!string.IsNullOrEmpty(gameProfile.World))
                    {
                        info.WorldId = gameProfile.World;
                    }
                }
                return info;
            });

        Debug.Log("------- [Stove-Sample] GameLog.Configure -------");
    }

    // 서버 game_log_batch_size 설정값(문자열)을 int 로 파싱. 없거나 형식 오류 시 기본 50.
    // "0" 이면 0 그대로 반영되어 모듈에서 기능 비활성 처리된다.
    private static int ParseBatchSize(string value)
    {
        int parsed;
        if (!string.IsNullOrEmpty(value) && int.TryParse(value, out parsed))
        {
            return parsed;
        }
        return 50;
    }

    // 서버 gds 설정값(JSON 문자열)을 Dictionary 로 파싱. 없거나 형식 오류 시 빈 맵.
    private static Dictionary<string, object> ParseGds(string gdsString)
    {
        if (string.IsNullOrEmpty(gdsString))
        {
            return new Dictionary<string, object>();
        }
        var parsed = Json.Deserialize(gdsString) as Dictionary<string, object>;
        return parsed ?? new Dictionary<string, object>();
    }

    // SDK 언어 설정을 로그 locale 코드로 변환 (native SGSLocalization.languageString 대응).
    private static string GetLanguageCode()
    {
        switch (Localization.GetLanguage())
        {
            case Localization.Language.Korean: return "ko";
            case Localization.Language.English: return "en";
            case Localization.Language.Spanish: return "es";
            case Localization.Language.SimplifiedChinese: return "zh-CN";
            case Localization.Language.TraditionalChinese: return "zh-TW";
            case Localization.Language.German: return "de";
            case Localization.Language.French: return "fr";
            case Localization.Language.Indonesian: return "id";
            case Localization.Language.Italian: return "it";
            case Localization.Language.Japanese: return "ja";
            case Localization.Language.Portuguese: return "pt";
            case Localization.Language.Russian: return "ru";
            case Localization.Language.Turkish: return "tr";
            case Localization.Language.Thai: return "th";
            case Localization.Language.Czech: return "cs";
            case Localization.Language.Malay: return "ms";
            case Localization.Language.Dutch: return "nl";
            case Localization.Language.Polish: return "pl";
            case Localization.Language.Vietnamese: return "vi";
            default: return "ko";
        }
    }

    public void AddGameLog() {
        GameLogDialog.Show((string parameters, string additionalParameters) =>
        {
            if (parameters == null && additionalParameters == null) {}
            else {

                GameLogEvent logEvent = new GameLogEvent();

                if (!string.IsNullOrEmpty(parameters))
                {
                    var parsedParams = Json.Deserialize(parameters) as Dictionary<string, object>;
                    if (parsedParams == null)
                    {
                        Debug.Log("------- [Stove-Sample] GameLog.Add failed: parameters is not valid JSON format -------");
                        return;
                    }
                    logEvent.Parameters = parsedParams;
                }

                if (!string.IsNullOrEmpty(additionalParameters))
                {
                    var parsedAdditionalParams = Json.Deserialize(additionalParameters) as Dictionary<string, object>;
                    if (parsedAdditionalParams == null)
                    {
                        Debug.Log("------- [Stove-Sample] GameLog.Add failed: additionalParameters is not valid JSON format -------");
                        return;
                    }
                    logEvent.AdditionalParameters = parsedAdditionalParams;
                }

                Debug.Log("------- [Stove-Sample] GameLog.Add -------");

                GameLog.Add(logEvent, (GameLogResult result) =>
                {
                    Debug.Log("------- [Stove-Sample] GameLog.Add : " + result + " -------");

                    if (result.IsSuccess)
                    {
                        SSTools.ShowMessage("GameLog.Add Success", SSTools.Position.bottom, SSTools.Time.oneSecond);
                    }
                    else
                    {
                        SSTools.ShowMessage("   Log.Add Fail", SSTools.Position.bottom, SSTools.Time.oneSecond);
                    }
                });
            }
        });
    }

    public void FlushGameLog()
    {
        GameLog.Flush();

        Debug.Log("------- [Stove-Sample] GameLog.Flush -------");
    }

    public void AddGameLogNCount() {
        // 1. TextFieldOneDialog로 전송할 횟수를 입력받음
        TextFieldOneDialog.Show((string count) =>
        {
            // 2. cancel이면 그냥 종료
            if (count == null)
            {
                return;
            }

            int convertCount = Convert.ToInt32(count);

            // 3. OK이면 GameLogDialog를 띄워서 내용 입력
            GameLogDialog.Show((string parameters, string additionalParameters) =>
            {
                // GameLogDialog 에서 cancel 이면 종료
                if (parameters == null && additionalParameters == null)
                {
                    return;
                }

                // 입력 값으로 GameLogEvent 구성
                GameLogEvent logEvent = new GameLogEvent();

                if (!string.IsNullOrEmpty(parameters))
                {
                    var parsedParams = Json.Deserialize(parameters) as Dictionary<string, object>;
                    if (parsedParams == null)
                    {
                        Debug.Log("------- [Stove-Sample] GameLog.AddNCount failed: parameters is not valid JSON format -------");
                        return;
                    }
                    logEvent.Parameters = parsedParams;
                }

                if (!string.IsNullOrEmpty(additionalParameters))
                {
                    var parsedAdditionalParams = Json.Deserialize(additionalParameters) as Dictionary<string, object>;
                    if (parsedAdditionalParams == null)
                    {
                        Debug.Log("------- [Stove-Sample] GameLog.AddNCount failed: additionalParameters is not valid JSON format -------");
                        return;
                    }
                    logEvent.AdditionalParameters = parsedAdditionalParams;
                }

                // 4. GameLogDialog 에서 OK를 누르면 지정된 횟수만큼 GameLog.Add 실행
                for (int i = 0; i < convertCount; i++)
                {
                    int currentIndex = i;
                    Debug.Log("------- [Stove-Sample] GameLog.AddNCount start : " + currentIndex + " / " + convertCount + " -------");

                    GameLog.Add(logEvent, (GameLogResult result) =>
                    {
                        Debug.Log("------- [Stove-Sample] GameLog.AddNCount end : " + currentIndex + " / " + convertCount + " -------");

                        if (result.IsSuccess)
                        {
                            SSTools.ShowMessage("GameLog.Add Success (" + (currentIndex + 1) + "/" + convertCount + ")", SSTools.Position.bottom, SSTools.Time.oneSecond);
                        }
                        else
                        {
                            SSTools.ShowMessage("GameLog.Add Fail (" + (currentIndex + 1) + "/" + convertCount + ")", SSTools.Position.bottom, SSTools.Time.oneSecond);
                        }
                    });
                }

                Debug.Log("------- [Stove-Sample] GameLog.AddNCount completed: " + convertCount + " events -------");
            });
        });
    }
}
