using System.Text.Json;
using Front.Program.Services;
using Front.Program.Models;
using Microsoft.JSInterop;

namespace Front.Program.ViewModels;

public class UserStateService(StorageService _storageService,SecureService _secureService, IJSRuntime _js) 
{
    public UserData UserData { get; set; } = new UserData();
    
    public bool isFirstCheck { get; set; } = false;
    public bool isLogin { get; set; } = false;
    
    
    public async Task<(bool success, UserData? userData)> GetUserDataFromStorageAsync()
    {
        try
        {
            var encUserData = await _storageService.GetItemAsync("USER_DATA");
            
            if (!string.IsNullOrEmpty(encUserData))
            {
                
                var decUserData = await _secureService.DecryptAsync(encUserData);

                var userData = JsonSerializer.Deserialize<UserData>(decUserData,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
                
                Console.WriteLine($"UserData: {userData.Name}, {userData.Type}");
                
                
                return (true, userData);
            }
            else
            {
                return (false, null);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error [GetUserDataFormAsync] : {ex.Message}");
            return (false, null);
        }
    }

    public async Task<(bool success, UserData? userData)> GetUserDataFromServerAsync()
    {
        
        var headerValue = await _storageService.GetItemAsync("Web_AM_Connect_Key");
        if (string.IsNullOrEmpty(headerValue)) return (false, null);
        
        var args = new {
            url = "/api/v1/in/user",
            method = "GET",
            headerKey = "Web_AM_Connect_Key",
            headerValue = headerValue,
            token = "VO00"
        };
        
        var response = await _js.InvokeAsync<JsonElement>(
            "fetchWithHeaderAndReturnUrl",
            args
        );
        
        // var response = await _js.InvokeAsync<JsonElement>("fetchWithHeaderAndReturnUrl", 
        //     "/api/v1/in/user/", 
        //     "GET", 
        //     "Web_AM_Connect_Key", 
        //     headerValue);
        
        Console.WriteLine($"JSON 응답: {response.ToString()}");

        if (response.TryGetProperty("data", out var dataElement))
        {
            try
            {
                // 전체 데이터 암호화 저장
                var userDataJson = dataElement.ToString();
                var userData = JsonSerializer.Deserialize<UserData>(userDataJson,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
                    
                if (userData != null && !string.IsNullOrEmpty(userData.Name))
                {
                    var encryptedData = await _secureService.EncryptAsync(userDataJson);
                    await _storageService.SetItemAsync("USER_DATA", encryptedData);
                    return (true, userData);
                }
                else
                {
                    Console.WriteLine("사용자 데이터에 필수 정보가 없습니다");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"사용자 데이터 처리 중 오류: {ex.Message}");
            }
        }

        Console.WriteLine("사용자 데이터를 찾을 수 없습니다");
        return (false, null);
    } 

    public async Task<bool> GetUserDataAsync()
    {
        try
        {
            Console.WriteLine("GetUserDataAsync 호출됨");
            // 로그인 상태가 아니라면 애초에 할 필요 없음
            if (await _storageService.GetItemAsync("IsLogin") != "true")
            {
                isLogin = false;
                return false;
            }

            var userDataForm = await GetUserDataFromStorageAsync();

            if (userDataForm.success && userDataForm.userData != null)
            {
                // 사용자 데이터가 성공적으로 로드되었을 때의 로직
                UserData = userDataForm.userData;
                isLogin = true;
                return true;
            }
            else
            {
                var userDataFromServer = await GetUserDataFromServerAsync();
                if (userDataFromServer.success && userDataFromServer.userData != null)
                {
                    // 서버에서 사용자 데이터를 성공적으로 로드했을 때의 로직
                    UserData = userDataFromServer.userData;
                    isLogin = true;
                    return true;
                }
                else
                {
                    // 사용자 데이터를 로드하지 못했을 때의 로직
                    Console.WriteLine("사용자 데이터를 로드하지 못했습니다.");
                    isLogin = false;
                    return false;
                }
            }
        }
        finally
        {
            if (!isFirstCheck) isFirstCheck = true;
        }
    }
    
    public async Task ClearUserData()
    {
        try
        {
            await _storageService.RemoveItemAsync("USER_DATA");
            await _storageService.RemoveItemAsync("IsLogin");
            Console.WriteLine("사용자 데이터 삭제 성공");
            isLogin = false;
            // return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"사용자 데이터 삭제 중 오류: {ex.Message}");
            // return false;
        }
    }
    
}