using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif

// 발판으로서 필요한 동작을 담은 스크립트
public class Platform : MonoBehaviour {
    public enum PlatformPattern {
        Random,
        Empty,
        LowLeft,
        LowMid,
        LowRight,
        Slide,
        ForceHit
    }

    public enum MileagePattern {
        Random,
        None,
        SafeLine,
        JumpArc,
        SlideLine
    }

    public enum ItemPattern {
        None,
        HealthSushi,
        InvincibleRamen,
        Shield,
        SpeedShoes,
        MileageCard
    }

    public enum PlatformSkin {
        Airport,
        Japan,
        China,
        USA
    }

    public GameObject[] obstacles; // 장애물 오브젝트들
    public int emptyPatternWeight = 2; // 장애물이 없는 패턴이 선택될 가중치
    public Sprite mileageSprite; // 이 발판에서 사용할 마일리지 토큰 스프라이트
    public int mileagePatternChance = 50; // 마일리지 패턴 등장 확률
    public int smallMileageValue = 10; // 일반 토큰 가치
    public int bonusMileageValue = 30; // 어려운 루트 보너스 토큰 가치

    private bool stepped = false; // 플레이어 캐릭터가 밟았었는가
    private MileagePickup[] mileagePickups; // 런타임에 생성하는 마일리지 토큰 풀
    private ItemPickup[] itemPickups; // 런타임에 생성하는 튜토리얼 아이템 풀
    private PlatformPattern reservedPattern = PlatformPattern.Random; // 다음 활성화 때 사용할 수동 패턴
    private MileagePattern reservedMileagePattern = MileagePattern.Random; // 다음 활성화 때 사용할 마일리지 패턴
    private SlideObstaclePattern.SlideLayout reservedSlideLayout = SlideObstaclePattern.SlideLayout.Random; // 다음 슬라이딩 장애물 배치
    private ItemPattern reservedItemPattern = ItemPattern.None; // 다음 활성화 때 사용할 아이템 배치
    private PlatformSkin reservedSkin = PlatformSkin.Airport; // 현재 맵에서 사용할 발판/장애물 스킨
    private const int MileagePoolSize = 5;
    private const int ItemPoolSize = 1;
    private const float MileageTokenScale = 0.55f;
    private const float MileageColliderRadius = 0.4f;
    private const float ItemTokenScale = 0.68f;
    private const float ItemColliderRadius = 0.46f;
    private const float JumpMileageMinWidthScale = 1.8f;
    private const float JumpMileageMaxWidthScale = 2.5f;

    public void ConfigureForTutorial(
        PlatformPattern pattern,
        MileagePattern mileagePattern,
        SlideObstaclePattern.SlideLayout slideLayout = SlideObstaclePattern.SlideLayout.Random,
        ItemPattern itemPattern = ItemPattern.None,
        PlatformSkin platformSkin = PlatformSkin.Airport) {
        reservedPattern = pattern;
        reservedMileagePattern = mileagePattern;
        reservedSlideLayout = slideLayout;
        reservedItemPattern = itemPattern;
        reservedSkin = platformSkin;
    }

    public void ConfigureForRandom(PlatformSkin platformSkin = PlatformSkin.Airport) {
        reservedPattern = PlatformPattern.Random;
        reservedMileagePattern = MileagePattern.Random;
        reservedSlideLayout = SlideObstaclePattern.SlideLayout.Random;
        reservedItemPattern = ItemPattern.None;
        reservedSkin = platformSkin;
    }

    // 컴포넌트가 활성화될때 마다 매번 실행되는 메서드
    private void OnEnable() {
        // 발판을 리셋하는 처리

        stepped = false;
        ApplyVisualSkin();
        EnsureMileagePickups();
        EnsureItemPickups();

        for(int i = 0; i < obstacles.Length; i++)
        {
            obstacles[i].SetActive(false);
        }

        HideMileagePickups();
        HideItemPickups();

        if(reservedPattern != PlatformPattern.Random)
        {
            ApplyReservedPattern();
            return;
        }

        if(obstacles.Length == 0)
        {
            TryPlaceMileagePattern(null);
            return;
        }

        // 낮은 장애물과 높은 장애물이 동시에 켜져 불가능한 배치가 되지 않도록 하나만 선택한다.
        int patternIndex = Random.Range(0, obstacles.Length + emptyPatternWeight);
        GameObject activeObstacle = null;

        if(patternIndex < obstacles.Length)
        {
            activeObstacle = obstacles[patternIndex];
            ConfigureSlideObstacle(activeObstacle);
            activeObstacle.SetActive(true);
        }

        TryPlaceMileagePattern(activeObstacle);
    }

    void OnCollisionEnter2D(Collision2D collision) {
        // 플레이어 캐릭터가 자신을 밟았을때 점수를 추가하는 처리
        if(collision.collider.tag == "Player" && !stepped && GameFlowManager.IsGameplayActive)
        {
            stepped = true;
            GameManager.instance.AddScore(1);
        }
    }

    private void EnsureMileagePickups() {
        if(mileagePickups != null && mileagePickups.Length == MileagePoolSize)
        {
            return;
        }

        mileagePickups = new MileagePickup[MileagePoolSize];

        for(int i = 0; i < MileagePoolSize; i++)
        {
            GameObject pickupObject = new GameObject("Mileage Pickup " + (i + 1));
            pickupObject.transform.SetParent(transform);
            pickupObject.transform.localScale = GetParentScaleCompensatedVector(MileageTokenScale);

            SpriteRenderer spriteRenderer = pickupObject.AddComponent<SpriteRenderer>();
            spriteRenderer.sprite = mileageSprite;
            spriteRenderer.sortingLayerName = "Foreground";
            spriteRenderer.sortingOrder = 1;

            CircleCollider2D pickupCollider = pickupObject.AddComponent<CircleCollider2D>();
            pickupCollider.isTrigger = true;
            pickupCollider.radius = MileageColliderRadius;

            mileagePickups[i] = pickupObject.AddComponent<MileagePickup>();
            mileagePickups[i].Setup(mileageSprite, smallMileageValue);

            pickupObject.SetActive(false);
        }
    }

    private void EnsureItemPickups() {
        if(itemPickups != null && itemPickups.Length == ItemPoolSize)
        {
            return;
        }

        itemPickups = new ItemPickup[ItemPoolSize];

        for(int i = 0; i < ItemPoolSize; i++)
        {
            GameObject pickupObject = new GameObject("Tutorial Item Pickup " + (i + 1));
            pickupObject.transform.SetParent(transform);
            pickupObject.transform.localScale = GetParentScaleCompensatedVector(ItemTokenScale);

            SpriteRenderer spriteRenderer = pickupObject.AddComponent<SpriteRenderer>();
            spriteRenderer.sortingLayerName = "Foreground";
            spriteRenderer.sortingOrder = 2;

            CircleCollider2D pickupCollider = pickupObject.AddComponent<CircleCollider2D>();
            pickupCollider.isTrigger = true;
            pickupCollider.radius = ItemColliderRadius;

            itemPickups[i] = pickupObject.AddComponent<ItemPickup>();
            pickupObject.SetActive(false);
        }
    }

    private void HideMileagePickups() {
        if(mileagePickups == null)
        {
            return;
        }

        for(int i = 0; i < mileagePickups.Length; i++)
        {
            if(mileagePickups[i] != null)
            {
                mileagePickups[i].gameObject.SetActive(false);
            }
        }
    }

    private void HideItemPickups() {
        if(itemPickups == null)
        {
            return;
        }

        for(int i = 0; i < itemPickups.Length; i++)
        {
            if(itemPickups[i] != null)
            {
                itemPickups[i].gameObject.SetActive(false);
            }
        }
    }

    private void TryPlaceMileagePattern(GameObject activeObstacle) {
        if(mileageSprite == null || mileagePickups == null || Random.Range(0, 100) >= mileagePatternChance)
        {
            return;
        }

        if(activeObstacle == null)
        {
            PlaceSafeMileageLine();
            return;
        }

        if(activeObstacle.name.Contains("Slide"))
        {
            PlaceSlideMileageLine();
        }
        else
        {
            PlaceJumpMileageArc(GetWorldRelativeX(activeObstacle.transform));
        }
    }

    private void ApplyReservedPattern() {
        GameObject activeObstacle = null;

        switch(reservedPattern)
        {
            case PlatformPattern.LowLeft:
                activeObstacle = FindObstacle("Obstacle Left");
                break;
            case PlatformPattern.LowMid:
                activeObstacle = FindObstacle("Obstacle Mid");
                break;
            case PlatformPattern.LowRight:
                activeObstacle = FindObstacle("Obstacle Right");
                break;
            case PlatformPattern.Slide:
                activeObstacle = FindObstacle("Slide Obstacle Pattern");
                break;
            case PlatformPattern.ForceHit:
                activeObstacle = FindObstacle("Obstacle Mid");
                ActivateObstacle(activeObstacle);

                GameObject slideObstacle = FindObstacle("Slide Obstacle Pattern");
                reservedSlideLayout = SlideObstaclePattern.SlideLayout.WidePair;
                ActivateObstacle(slideObstacle);
                break;
        }

        if(reservedPattern != PlatformPattern.ForceHit && activeObstacle != null)
        {
            ActivateObstacle(activeObstacle);
        }

        PlaceReservedMileagePattern(activeObstacle);
        PlaceReservedItemPattern();
    }

    private void ActivateObstacle(GameObject obstacle) {
        if(obstacle == null)
        {
            return;
        }

        ConfigureSlideObstacle(obstacle);
        obstacle.SetActive(true);
    }

    private void ConfigureSlideObstacle(GameObject activeObstacle) {
        if(activeObstacle == null || !activeObstacle.name.Contains("Slide"))
        {
            return;
        }

        SlideObstaclePattern slideObstaclePattern = activeObstacle.GetComponent<SlideObstaclePattern>();
        if(slideObstaclePattern != null)
        {
            slideObstaclePattern.ConfigureLayout(reservedSlideLayout);
        }
    }

    private GameObject FindObstacle(string obstacleName) {
        for(int i = 0; i < obstacles.Length; i++)
        {
            if(obstacles[i] != null && obstacles[i].name == obstacleName)
            {
                return obstacles[i];
            }
        }

        return null;
    }

    private void PlaceReservedMileagePattern(GameObject activeObstacle) {
        if(mileageSprite == null || mileagePickups == null || reservedMileagePattern == MileagePattern.None)
        {
            return;
        }

        if(reservedMileagePattern == MileagePattern.SafeLine)
        {
            PlaceSafeMileageLine();
            return;
        }

        if(reservedMileagePattern == MileagePattern.JumpArc)
        {
            float obstacleX = activeObstacle != null ? GetWorldRelativeX(activeObstacle.transform) : 0f;
            PlaceJumpMileageArc(obstacleX);
            return;
        }

        if(reservedMileagePattern == MileagePattern.SlideLine)
        {
            PlaceSlideMileageLine();
            return;
        }

        TryPlaceMileagePattern(activeObstacle);
    }

    private void PlaceReservedItemPattern() {
        if(reservedItemPattern == ItemPattern.None || itemPickups == null || itemPickups.Length == 0)
        {
            return;
        }

        GameManager.TutorialItemType itemType = GetTutorialItemType(reservedItemPattern);
        ItemPickup pickup = itemPickups[0];
        pickup.Setup(LoadItemSprite(itemType), itemType);
        pickup.transform.localPosition = GetParentScaleCompensatedPosition(GetItemPosition(reservedItemPattern));
        pickup.ResetPickup();
    }

    private GameManager.TutorialItemType GetTutorialItemType(ItemPattern itemPattern) {
        switch(itemPattern)
        {
            case ItemPattern.InvincibleRamen:
                return GameManager.TutorialItemType.InvincibleRamen;
            case ItemPattern.Shield:
                return GameManager.TutorialItemType.Shield;
            case ItemPattern.SpeedShoes:
                return GameManager.TutorialItemType.SpeedShoes;
            case ItemPattern.MileageCard:
                return GameManager.TutorialItemType.MileageCard;
            case ItemPattern.HealthSushi:
            default:
                return GameManager.TutorialItemType.HealthSushi;
        }
    }

    private Vector2 GetItemPosition(ItemPattern itemPattern) {
        const float frontX = -1.45f;

        switch(itemPattern)
        {
            case ItemPattern.HealthSushi:
                return new Vector2(frontX, 1.55f);
            case ItemPattern.InvincibleRamen:
                return new Vector2(frontX, 1.55f);
            case ItemPattern.Shield:
                return new Vector2(frontX, 1.55f);
            case ItemPattern.SpeedShoes:
                return new Vector2(frontX, 1.55f);
            case ItemPattern.MileageCard:
                return new Vector2(frontX, 1.55f);
            default:
                return new Vector2(0f, 1.55f);
        }
    }

    private void ApplyVisualSkin() {
#if UNITY_EDITOR
        Sprite platformSprite = LoadSpriteAtPath(GetPlatformSkinPath(reservedSkin));
        Sprite ceilingSprite = LoadSpriteAtPath(GetCeilingSkinPath(reservedSkin));
        Sprite lowObstacleSprite = LoadSpriteAtPath(GetLowObstacleSkinPath(reservedSkin));
        Sprite hangingObstacleSprite = LoadSpriteAtPath(GetHangingObstacleSkinPath(reservedSkin));
        Sprite mileageSkinSprite = LoadSpriteAtPath(GetMileageSkinPath(reservedSkin));

        ApplySprite(GetComponent<SpriteRenderer>(), platformSprite);

        Transform ceilingPlatform = FindChildRecursive(transform, "Ceiling Platform");
        if(ceilingPlatform != null)
        {
            ApplySprite(ceilingPlatform.GetComponent<SpriteRenderer>(), ceilingSprite != null ? ceilingSprite : platformSprite);
        }

        ApplyLowObstacleSkin(lowObstacleSprite);
        ApplyHangingObstacleSkin(hangingObstacleSprite);

        if(mileageSkinSprite != null)
        {
            mileageSprite = mileageSkinSprite;
        }
#endif
    }

#if UNITY_EDITOR
    private void ApplyLowObstacleSkin(Sprite obstacleSprite) {
        if(obstacleSprite == null || obstacles == null)
        {
            return;
        }

        for(int i = 0; i < obstacles.Length; i++)
        {
            GameObject obstacle = obstacles[i];
            if(obstacle == null || obstacle.name.Contains("Slide"))
            {
                continue;
            }

            ApplySprite(obstacle.GetComponent<SpriteRenderer>(), obstacleSprite);
        }
    }

    private void ApplyHangingObstacleSkin(Sprite obstacleSprite) {
        if(obstacleSprite == null)
        {
            return;
        }

        GameObject slideObstacle = FindObstacle("Slide Obstacle Pattern");
        if(slideObstacle == null)
        {
            return;
        }

        SlideObstaclePattern slideObstaclePattern = slideObstacle.GetComponent<SlideObstaclePattern>();
        if(slideObstaclePattern == null || slideObstaclePattern.obstacles == null)
        {
            return;
        }

        for(int i = 0; i < slideObstaclePattern.obstacles.Length; i++)
        {
            Transform hangingObstacle = slideObstaclePattern.obstacles[i];
            if(hangingObstacle != null)
            {
                ApplySprite(hangingObstacle.GetComponent<SpriteRenderer>(), obstacleSprite);
            }
        }
    }

    private void ApplySprite(SpriteRenderer spriteRenderer, Sprite sprite) {
        if(spriteRenderer != null && sprite != null)
        {
            spriteRenderer.sprite = sprite;
        }
    }

    private Sprite LoadSpriteAtPath(string assetPath) {
        if(string.IsNullOrEmpty(assetPath))
        {
            return null;
        }

        return AssetDatabase.LoadAssetAtPath<Sprite>(assetPath);
    }

    private Transform FindChildRecursive(Transform parent, string childName) {
        if(parent == null)
        {
            return null;
        }

        for(int i = 0; i < parent.childCount; i++)
        {
            Transform child = parent.GetChild(i);

            if(child.name == childName)
            {
                return child;
            }

            Transform match = FindChildRecursive(child, childName);
            if(match != null)
            {
                return match;
            }
        }

        return null;
    }

    private string GetPlatformSkinPath(PlatformSkin platformSkin) {
        switch(platformSkin)
        {
            case PlatformSkin.Japan:
                return "Assets/Sprites/ObstacleSkins/Skin_Platform_Japan.png";
            case PlatformSkin.China:
                return "Assets/Sprites/ObstacleSkins/Skin_Platform_China.png";
            case PlatformSkin.USA:
                return "Assets/Sprites/ObstacleSkins/Skin_Platform_USA.png";
            case PlatformSkin.Airport:
            default:
                return "Assets/Sprites/ObstacleSkins/Skin_Platform_AirportFloorTile.png";
        }
    }

    private string GetCeilingSkinPath(PlatformSkin platformSkin) {
        if(platformSkin == PlatformSkin.Airport)
        {
            return "Assets/Sprites/ObstacleSkins/Skin_Platform_AirportCeiling.png";
        }

        return GetPlatformSkinPath(platformSkin);
    }

    private string GetLowObstacleSkinPath(PlatformSkin platformSkin) {
        switch(platformSkin)
        {
            case PlatformSkin.Japan:
                return "Assets/Sprites/ObstacleSkins/Skin_Obstacle_StoneLantern.png";
            case PlatformSkin.China:
                return "Assets/Sprites/ObstacleSkins/Skin_Obstacle_MarketCrate.png";
            case PlatformSkin.USA:
                return "Assets/Sprites/ObstacleSkins/Skin_Obstacle_Cone.png";
            case PlatformSkin.Airport:
            default:
                return "Assets/Sprites/ObstacleSkins/Skin_Obstacle_Suitcases.png";
        }
    }

    private string GetHangingObstacleSkinPath(PlatformSkin platformSkin) {
        switch(platformSkin)
        {
            case PlatformSkin.Japan:
                return "Assets/Sprites/ObstacleSkins/Skin_Hanging_RoadSign.png";
            case PlatformSkin.China:
                return "Assets/Sprites/ObstacleSkins/Skin_Hanging_RedLanterns.png";
            case PlatformSkin.USA:
                return "Assets/Sprites/ObstacleSkins/Skin_Hanging_Banner.png";
            case PlatformSkin.Airport:
            default:
                return "Assets/Sprites/ObstacleSkins/Skin_Hanging_AirportSign.png";
        }
    }

    private string GetMileageSkinPath(PlatformSkin platformSkin) {
        switch(platformSkin)
        {
            case PlatformSkin.Japan:
                return "Assets/Sprites/Mileage/Mileage_Japan.png";
            case PlatformSkin.China:
                return "Assets/Sprites/Mileage/Mileage_China.png";
            case PlatformSkin.USA:
                return "Assets/Sprites/Mileage/Mileage_USA.png";
            case PlatformSkin.Airport:
            default:
                return "Assets/Sprites/Mileage/Mileage_Korea.png";
        }
    }
#endif

    private Sprite LoadItemSprite(GameManager.TutorialItemType itemType) {
#if UNITY_EDITOR
        string assetPath = "";

        switch(itemType)
        {
            case GameManager.TutorialItemType.InvincibleRamen:
                assetPath = "Assets/Sprites/Items/Item_Invincible_Ramen.png";
                break;
            case GameManager.TutorialItemType.Shield:
                assetPath = "Assets/Sprites/Items/Item_Shield.png";
                break;
            case GameManager.TutorialItemType.SpeedShoes:
                assetPath = "Assets/Sprites/Items/Item_Speed_Shoes.png";
                break;
            case GameManager.TutorialItemType.MileageCard:
                assetPath = "Assets/Sprites/Items/Item_Mileage_Card.png";
                break;
            case GameManager.TutorialItemType.HealthSushi:
            default:
                assetPath = "Assets/Sprites/Items/Item_Health_Sushi.png";
                break;
        }

        return AssetDatabase.LoadAssetAtPath<Sprite>(assetPath);
#else
        return null;
#endif
    }

    private void PlaceSafeMileageLine() {
        Vector2[] positions = {
            new Vector2(-2f, 1.35f),
            new Vector2(-1f, 1.35f),
            new Vector2(0f, 1.35f),
            new Vector2(1f, 1.35f),
            new Vector2(2f, 1.35f)
        };

        PlaceMileageTokens(positions, smallMileageValue);
    }

    private void PlaceJumpMileageArc(float obstacleX) {
        float widthScale = GetJumpMileageArcWidthScale();
        Vector2[] positions = {
            new Vector2(obstacleX - 2.25f * widthScale, 1.88f),
            new Vector2(obstacleX - 1.15f * widthScale, 2.88f),
            new Vector2(obstacleX, 3.58f),
            new Vector2(obstacleX + 1.15f * widthScale, 2.88f),
            new Vector2(obstacleX + 2.25f * widthScale, 1.88f)
        };

        PlaceMileageTokens(positions, smallMileageValue);
        SetPickupValue(2, bonusMileageValue);
    }

    private float GetJumpMileageArcWidthScale() {
        if(GameManager.instance == null)
        {
            return JumpMileageMinWidthScale;
        }

        float minSpeed = Mathf.Max(0.1f, GameManager.instance.minGameSpeed);
        float maxSpeed = Mathf.Max(minSpeed + 0.1f, GameManager.instance.maxGameSpeed);
        float speedProgress = Mathf.InverseLerp(minSpeed, maxSpeed, GameManager.instance.gameSpeed);
        return Mathf.Lerp(JumpMileageMinWidthScale, JumpMileageMaxWidthScale, speedProgress);
    }

    private void PlaceSlideMileageLine() {
        Vector2[] positions = {
            new Vector2(-1.5f, 1.05f),
            new Vector2(-0.5f, 1.05f),
            new Vector2(0.5f, 1.05f),
            new Vector2(1.5f, 1.05f)
        };

        PlaceMileageTokens(positions, smallMileageValue);
        SetPickupValue(2, bonusMileageValue);
    }

    private void PlaceMileageTokens(Vector2[] positions, int value) {
        int count = Mathf.Min(positions.Length, mileagePickups.Length);

        for(int i = 0; i < count; i++)
        {
            mileagePickups[i].Setup(mileageSprite, value);
            mileagePickups[i].transform.localPosition = GetParentScaleCompensatedPosition(positions[i]);
            mileagePickups[i].ResetPickup();
        }
    }

    private Vector3 GetParentScaleCompensatedVector(float scale) {
        float parentScaleX = Mathf.Approximately(transform.localScale.x, 0f) ? 1f : transform.localScale.x;
        float parentScaleY = Mathf.Approximately(transform.localScale.y, 0f) ? 1f : transform.localScale.y;
        return new Vector3(scale / parentScaleX, scale / parentScaleY, 1f);
    }

    private Vector3 GetParentScaleCompensatedPosition(Vector2 position) {
        float parentScaleX = Mathf.Approximately(transform.localScale.x, 0f) ? 1f : transform.localScale.x;
        float parentScaleY = Mathf.Approximately(transform.localScale.y, 0f) ? 1f : transform.localScale.y;
        return new Vector3(position.x / parentScaleX, position.y / parentScaleY, 0f);
    }

    private float GetWorldRelativeX(Transform child) {
        return child.localPosition.x * transform.localScale.x;
    }

    private void SetPickupValue(int index, int value) {
        if(index < 0 || index >= mileagePickups.Length || !mileagePickups[index].gameObject.activeSelf)
        {
            return;
        }

        mileagePickups[index].Setup(mileageSprite, value);
    }
}