#if UNITY_EDITOR
using System;
using System.IO;
using System.Reflection;
using UnityEditor;
using UnityEditor.Build.Reporting;
using UnityEngine;

public static class IAAAdAndroidBuild
{
    private const string OutputDirectory = "Build/Android";
    private const string OutputApkPath = OutputDirectory + "/IAAAdDebugSample-starveg.apk";
    private const string KeystorePath = "Build/Android/keys/starveg-test.keystore";
    private const string KeystorePassword = "Foldcc123!";
    private const string KeyAliasName = "starvegtest";
    private const string PackageName = "com.foldcc.starveg";

    [MenuItem("Topon/Build IAA Android Test APK")]
    public static void BuildAndroidTestApk()
    {
        EnsureBuildFolders();
        ConfigurePlayerSettings();
        var resolverState = CaptureResolverState();

        try
        {
            ApplyBatchFriendlyResolverSettings();

            var scenes = new[] { "Assets/Samples/IAAAdDebugSample/Scenes/IAAAdDebugSample.unity" };
            var options = new BuildPlayerOptions
            {
                scenes = scenes,
                target = BuildTarget.Android,
                locationPathName = OutputApkPath,
                options = BuildOptions.None
            };

            var report = BuildPipeline.BuildPlayer(options);
            if (report.summary.result != BuildResult.Succeeded)
            {
                throw new Exception(
                    $"Android APK build failed: {report.summary.result} ({report.summary.totalErrors} errors)");
            }

            Debug.Log($"[IAA Build] APK generated: {Path.GetFullPath(OutputApkPath)}");
        }
        finally
        {
            RestoreResolverState(resolverState);
        }
    }

    public static void BuildAndroidTestApkInBatchMode()
    {
        BuildAndroidTestApk();
        EditorApplication.Exit(0);
    }

    private static void ConfigurePlayerSettings()
    {
        PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.Android, PackageName);
        PlayerSettings.defaultInterfaceOrientation = UIOrientation.Portrait;
        PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARMv7 | AndroidArchitecture.ARM64;
        PlayerSettings.Android.useCustomKeystore = true;
        PlayerSettings.Android.keystoreName = Path.GetFullPath(KeystorePath);
        PlayerSettings.Android.keystorePass = KeystorePassword;
        PlayerSettings.Android.keyaliasName = KeyAliasName;
        PlayerSettings.Android.keyaliasPass = KeystorePassword;
        PlayerSettings.bundleVersion = string.IsNullOrWhiteSpace(PlayerSettings.bundleVersion)
            ? "1.0.0"
            : PlayerSettings.bundleVersion;
        PlayerSettings.Android.bundleVersionCode = Mathf.Max(1, PlayerSettings.Android.bundleVersionCode);
        AssetDatabase.SaveAssets();
    }

    private static void EnsureBuildFolders()
    {
        Directory.CreateDirectory(Path.GetFullPath(OutputDirectory));
        Directory.CreateDirectory(Path.GetFullPath(Path.GetDirectoryName(KeystorePath) ?? OutputDirectory));
    }

    private static ResolverState CaptureResolverState()
    {
        var settingsType = GetResolverSettingsType();
        return new ResolverState
        {
            EnableAutoResolution = GetResolverBool(settingsType, "EnableAutoResolution"),
            AutoResolveOnBuild = GetResolverBool(settingsType, "AutoResolveOnBuild"),
            PromptBeforeAutoResolution = GetResolverBool(settingsType, "PromptBeforeAutoResolution")
        };
    }

    private static void ApplyBatchFriendlyResolverSettings()
    {
        var settingsType = GetResolverSettingsType();
        SetResolverBool(settingsType, "EnableAutoResolution", false);
        SetResolverBool(settingsType, "AutoResolveOnBuild", false);
        SetResolverBool(settingsType, "PromptBeforeAutoResolution", false);
    }

    private static void RestoreResolverState(ResolverState state)
    {
        var settingsType = GetResolverSettingsType();
        SetResolverBool(settingsType, "EnableAutoResolution", state.EnableAutoResolution);
        SetResolverBool(settingsType, "AutoResolveOnBuild", state.AutoResolveOnBuild);
        SetResolverBool(settingsType, "PromptBeforeAutoResolution", state.PromptBeforeAutoResolution);
    }

    private static Type GetResolverSettingsType()
    {
        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            var type = assembly.GetType("GooglePlayServices.SettingsDialog");
            if (type != null)
            {
                return type;
            }
        }

        return null;
    }

    private static bool GetResolverBool(Type settingsType, string propertyName)
    {
        if (settingsType == null)
        {
            return false;
        }

        var property = settingsType.GetProperty(
            propertyName,
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
        if (property == null)
        {
            return false;
        }

        return (bool)property.GetValue(null, null);
    }

    private static void SetResolverBool(Type settingsType, string propertyName, bool value)
    {
        if (settingsType == null)
        {
            return;
        }

        var property = settingsType.GetProperty(
            propertyName,
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
        if (property == null)
        {
            return;
        }

        property.SetValue(null, value, null);
    }

    private struct ResolverState
    {
        public bool EnableAutoResolution;
        public bool AutoResolveOnBuild;
        public bool PromptBeforeAutoResolution;
    }
}
#endif