using UnityEngine;

namespace AppleHillsCamera
{
    /// <summary>
    /// Defines reference sizes and distances for screen adaptation.
    /// Used by CameraScreenAdapter and EdgeAnchor components.
    /// </summary>
    public class ScreenReferenceMarker : MonoBehaviour
    {
        [Header("Horizontal Reference")]
        [Tooltip("The target width that should match the screen width")]
        public float targetWidth = 10f;

        [Header("Vertical References")]
        [Tooltip("Distance from top of screen to use for anchoring")]
        public float topMargin = 1f;
        
        [Tooltip("Distance from bottom of screen to use for anchoring")]
        public float bottomMargin = 1f;
        
        [Tooltip("Distance from left of screen to use for anchoring")]
        public float leftMargin = 1f;
        
        [Tooltip("Distance from right of screen to use for anchoring")]
        public float rightMargin = 1f;

        [Header("Visualization")]
        [Tooltip("Color to use for gizmo visualization")]
        public Color gizmoColor = new Color(0f, 1f, 0f, 0.5f);
        
        [Tooltip("Color to use for screen edge visualization")]
        public Color screenEdgeColor = new Color(1f, 1f, 0f, 0.3f);
        
        [Tooltip("Show the vertical margins in scene view")]
        public bool showVerticalMargins = true;
        
        [Tooltip("Show the horizontal margins in scene view")]
        public bool showHorizontalMargins = true;

#if UNITY_EDITOR
        private void OnDrawGizmos()
        {
            // Save original color
            Color originalColor = Gizmos.color;
            
            // Set the color for our gizmos
            Gizmos.color = gizmoColor;
            
            Vector3 position = transform.position;
            
            // Draw the width reference
            Vector3 left = position + Vector3.left * (targetWidth / 2f);
            Vector3 right = position + Vector3.right * (targetWidth / 2f);
            Gizmos.DrawLine(left, right);
            
            // Draw vertical endpoints
            float endCapSize = 0.5f;
            Gizmos.DrawLine(left, left + Vector3.up * endCapSize);
            Gizmos.DrawLine(left, left + Vector3.down * endCapSize);
            Gizmos.DrawLine(right, right + Vector3.up * endCapSize);
            Gizmos.DrawLine(right, right + Vector3.down * endCapSize);
            
            // Calculate visual screen edges based on actual camera viewport
            float halfWidth = targetWidth / 2f;
            float halfHeight;
            
            // Try to get camera references in the preferred order
            
            // 1. Try to find the main camera in the scene (highest priority)
            Camera mainCamera = Camera.main;
            if (mainCamera != null && mainCamera.orthographic)
            {
                // Use the main camera's actual orthographic size for the height
                halfHeight = mainCamera.orthographicSize;
            }
            else
            {
                // 2. Use Game/Simulator window resolution
                float gameViewAspect = (float)Screen.height / Screen.width;
                halfHeight = halfWidth * gameViewAspect;
                
                // 3. Fallback to the scene view camera if needed
                UnityEditor.SceneView sceneView = UnityEditor.SceneView.lastActiveSceneView;
                if (sceneView != null && sceneView.camera != null && sceneView.camera.orthographic)
                {
                    // Use the scene view camera's aspect ratio instead
                    float sceneAspect = sceneView.camera.pixelHeight / (float)sceneView.camera.pixelWidth;
                    halfHeight = halfWidth * sceneAspect;
                }
            }
            
            // Screen edge positions
            Vector3 topEdge = position + Vector3.up * halfHeight;
            Vector3 bottomEdge = position + Vector3.down * halfHeight;
            Vector3 leftEdge = position + Vector3.left * halfWidth;
            Vector3 rightEdge = position + Vector3.right * halfWidth;
            
            // Draw screen edges with yellow color
            Gizmos.color = screenEdgeColor;
            
            // Draw full screen rectangle
            Gizmos.DrawLine(leftEdge + Vector3.up * halfHeight, rightEdge + Vector3.up * halfHeight); // Top edge
            Gizmos.DrawLine(leftEdge + Vector3.down * halfHeight, rightEdge + Vector3.down * halfHeight); // Bottom edge
            Gizmos.DrawLine(leftEdge + Vector3.up * halfHeight, leftEdge + Vector3.down * halfHeight); // Left edge
            Gizmos.DrawLine(rightEdge + Vector3.up * halfHeight, rightEdge + Vector3.down * halfHeight); // Right edge
            
            // Draw margin references if enabled
            Gizmos.color = gizmoColor;
            
            if (showVerticalMargins)
            {
                // Top margin (distance from top edge)
                Gizmos.DrawLine(
                    topEdge + Vector3.down * topMargin + Vector3.left * (targetWidth / 4f), 
                    topEdge + Vector3.down * topMargin + Vector3.right * (targetWidth / 4f));
                
                // Bottom margin (distance from bottom edge)
                Gizmos.DrawLine(
                    bottomEdge + Vector3.up * bottomMargin + Vector3.left * (targetWidth / 4f),
                    bottomEdge + Vector3.up * bottomMargin + Vector3.right * (targetWidth / 4f));
            }
            
            if (showHorizontalMargins)
            {
                // Left margin (distance from left edge)
                Gizmos.DrawLine(
                    leftEdge + Vector3.right * leftMargin + Vector3.up * (halfHeight / 2f),
                    leftEdge + Vector3.right * leftMargin + Vector3.down * (halfHeight / 2f));
                
                // Right margin (distance from right edge)
                Gizmos.DrawLine(
                    rightEdge + Vector3.left * rightMargin + Vector3.up * (halfHeight / 2f),
                    rightEdge + Vector3.left * rightMargin + Vector3.down * (halfHeight / 2f));
            }
            
            // Restore original color
            Gizmos.color = originalColor;
        }
#endif
    }
}