Camera.cs

using System.Drawing;
using System.Numerics;
using Gondwana.Drawing.Coordinates;
using Gondwana.Physics.Movement;
using Gondwana.Scenes;
 
namespace Gondwana.Rendering.Views;

public sealed class Camera
{
    private readonly Scene _scene;
    private PointF _positionPx = new(0, 0);
    private Func<PointF>? _followWorldPx;
    private bool _hardFollow;
    private SceneLayer? _followLayer;
    private int _followAxis; // 0 = both, 1 = screen X, 2 = screen Y
    private PointF _followAnchor = new(0.5f, 0.5f);
    private SceneLayer? TopologyLayer => _followLayer ?? _scene.SceneLayers.FirstOrDefault(layer => layer.Visible);
 
    // Explicit pan-to-target (camera upper-left) state.
    // This is used by PanTo and is independent of the "follow" target.
    private PointF? _panTargetUpperLeftPx;
    private float _panLerpPerSecond;

    public PointF PositionPx
    {
        get => _positionPx;
        private set
        {
            if (_positionPx != value)
            {
                _positionPx = value;
 
                if (_scene is not null)
                    _scene.FullRefreshNeeded = true;
            }
        }
    }

    public RectangleF WorldBoundsPx { get; set; } = RectangleF.Empty;

    public Rectangle DeadZonePx { get; set; } = Rectangle.Empty;

    public float FollowLerpPerSecond { get; set; } = 8f;
 
    internal Camera(Scene scene) => _scene = scene ?? throw new ArgumentNullException(nameof(scene));

    internal Func<SizeF> GetVisibleWorldSizePx { get; set; } = () => new SizeF(1280, 720);
 
    #region Camera movement methods

    public void SnapTo(PointF worldUpperLeftPx)
    {
        PositionPx = ClampToWorldBounds(worldUpperLeftPx);
    }

    public void CenterOn(PointF worldCenterPx)
    {
        var vis = GetVisibleWorldSizePx();
        SnapTo(new PointF(worldCenterPx.X - vis.Width * 0.5f,
                          worldCenterPx.Y - vis.Height * 0.5f));
    }

    public void CenterOnGrid(SceneLayer layer, int col, int row)
    {
        // Anchor (top-left of tile)
        var anchor = layer.GridToWorldPx(new PointF(col, row));
        float tileCenterX = anchor.X + layer.TileWidth * 0.5f;
        float tileCenterY = anchor.Y + layer.TileHeight * 0.5f;
 
        var vis = GetVisibleWorldSizePx();
 
        // Camera is top-left, so subtract half the visible size to center that point.
        var camTopLeft = new PointF(
            tileCenterX - vis.Width * 0.5f,
            tileCenterY - vis.Height * 0.5f);
 
        SnapTo(camTopLeft);
    }

    public void PanCenterTo(PointF worldCenterPx, float speed)
    {
        FollowLerpPerSecond = speed;
 
        // For center-based pans, we treat the target as a "point of interest"
        // and let the follow/dead-zone logic convert it to a camera UL.
        Follow(() => worldCenterPx, hardFollow: false);
    }

    public void AnimateCenterOnGrid(SceneLayer layer, int col, int row, float speed)
    {
        // Compute world center of the tile and reuse PanCenterTo.
        var anchor = layer.GridToWorldPx(new PointF(col, row));
        float tileCenterX = anchor.X + layer.TileWidth * 0.5f;
        float tileCenterY = anchor.Y + layer.TileHeight * 0.5f;
 
        PanCenterTo(new PointF(tileCenterX, tileCenterY), speed);
    }

    public void PanTo(PointF worldTopLeftPx, float speed)
    {
        // Cancel any center-based follow when we take direct manual control.
        _followAxis = 0;
        _followLayer = null;
        _followWorldPx = null;
        _hardFollow = false;
 
        if (speed <= 0f)
        {
            _panTargetUpperLeftPx = null;
            SnapTo(worldTopLeftPx);
            return;
        }
 
        _panLerpPerSecond = speed;
        _panTargetUpperLeftPx = ClampToWorldBounds(worldTopLeftPx);
    }

    public void PanCenterToOnce(PointF worldCenterPx, float speed)
    {
        // Compute the desired camera upper-left such that worldCenterPx
        // ends up in the middle of the visible region.
        var vis = GetVisibleWorldSizePx();
 
        var desiredUpperLeft = new PointF(
            worldCenterPx.X - vis.Width * 0.5f,
            worldCenterPx.Y - vis.Height * 0.5f);
 
        // Delegate to the existing pan-to-upper-left logic (which also clamps).
        PanTo(desiredUpperLeft, speed);
    }

    public void PanToOverDuration(PointF worldTopLeftPx, float durationSeconds)
    {
        if (durationSeconds <= 0f)
        {
            // Degenerate case — behave like SnapTo().
            _panTargetUpperLeftPx = null;
            SnapTo(worldTopLeftPx);
            return;
        }
 
        // In an exponential smoothing system:
        //      pos(t) = target + (pos0 - target) * exp(-k * t)
        //
        // To reach ~99% of target position in T seconds:
        //      exp(-k*T) = 0.01   →   k = -ln(0.01) / T
        //
        // This produces a visually nice, predictable time-to-arrive.
        float k = -(float)Math.Log(0.01f) / durationSeconds;
 
        // Cancel following and start a timed pan using your existing machinery.
        _followAxis = 0;
        _followLayer = null;
        _followWorldPx = null;
        _hardFollow = false;
 
        _panLerpPerSecond = k;
        _panTargetUpperLeftPx = ClampToWorldBounds(worldTopLeftPx);
    }

    public void PanCenterToOverDuration(PointF worldCenterPx, float durationSeconds)
    {
        // Compute the desired camera upper-left such that worldCenterPx
        // ends up in the middle of the visible region.
        var vis = GetVisibleWorldSizePx();
 
        var desiredUpperLeft = new PointF(
            worldCenterPx.X - vis.Width * 0.5f,
            worldCenterPx.Y - vis.Height * 0.5f);
 
        // Delegate to the duration-based UL pan logic.
        PanToOverDuration(desiredUpperLeft, durationSeconds);
    }

    public void PanToGridOverDuration(SceneLayer layer, int col, int row, float durationSeconds)
    {
        if (layer is null) throw new ArgumentNullException(nameof(layer));
 
        // Same pattern as AnimateCenterOnGrid: get the tile's world-space anchor
        // (top-left), then offset by half the tile size to get its visual center.
        var anchor = layer.GridToWorldPx(new PointF(col, row));
        float tileCenterX = anchor.X + layer.TileWidth * 0.5f;
        float tileCenterY = anchor.Y + layer.TileHeight * 0.5f;
 
        // Then pan so that tile center ends up at the center of the view
        // over the requested duration.
        PanCenterToOverDuration(new PointF(tileCenterX, tileCenterY), durationSeconds);
    }

    public void PanBy(PointF deltaPx)
    {
        SnapTo(new PointF(PositionPx.X + deltaPx.X,
                          PositionPx.Y + deltaPx.Y));
    }

    internal void CancelPan()
    {
        _panTargetUpperLeftPx = null;
        _panLerpPerSecond = 0f;
    }

    public void Follow(Func<PointF> getWorldPixel, bool hardFollow = false)
    {
        FollowAt(getWorldPixel, new PointF(0.5f, 0.5f), hardFollow);
    }

    public void FollowAt(Func<PointF> getWorldPixel, PointF viewportAnchor, bool hardFollow = false)
    {
        ArgumentNullException.ThrowIfNull(getWorldPixel);
        ValidateViewportAnchor(viewportAnchor, nameof(viewportAnchor));
 
        _followAxis = 0;
        _followLayer = null;
        _followWorldPx = getWorldPixel;
        _followAnchor = viewportAnchor;
        _hardFollow = hardFollow;
    }

    public void FollowTo(PointF worldPointOfInterestPx)
    {
        // Freeze the value so the camera lerps toward a fixed point.
        Follow(() => worldPointOfInterestPx);
    }

    public void FollowCentered(IMovableOnSceneLayer target, float speed = -1f, bool hard = false)
    {
        FollowAt(target, new PointF(0.5f, 0.5f), speed, hard);
    }

    public void FollowAt(IMovableOnSceneLayer target, PointF viewportAnchor, float speed = -1f, bool hard = false)
    {
        ArgumentNullException.ThrowIfNull(target);
        ValidateViewportAnchor(viewportAnchor, nameof(viewportAnchor));
 
        if (speed > 0f)
            FollowLerpPerSecond = speed;
 
        FollowAt(() =>
        {
            var layer = target.SceneLayer;
            var pos = target.GetPosition();
 
            return target.PositionSpace == MovementSpace.Grid
                ? GetCenteredTile(layer, pos)
                : new PointF(pos.X, pos.Y);
        },
        viewportAnchor,
        hard);
        _followLayer = target.SceneLayer;
    }

    public void FollowCenteredX(IMovableOnSceneLayer target, float speed = -1f, bool hard = false)
    {
        FollowAtX(target, 0.5f, speed, hard);
    }

    public void FollowAtX(IMovableOnSceneLayer target, float horizontalAnchor, float speed = -1f, bool hard = false)
    {
        ArgumentNullException.ThrowIfNull(target);
        ValidateNormalizedAnchor(horizontalAnchor, nameof(horizontalAnchor));
 
        if (speed > 0f)
            FollowLerpPerSecond = speed;
 
        FollowAt(() =>
        {
            var layer = target.SceneLayer;
            var pos = target.GetPosition();
 
            float worldCenterX;
            if (target.PositionSpace == MovementSpace.Grid)
            {
                var anchor = layer.GridToWorldPx(new PointF(pos.X, pos.Y));
                worldCenterX = anchor.X + layer.TileWidth * 0.5f;
            }
            else
            {
                worldCenterX = pos.X;
            }
 
            var vis = GetVisibleWorldSizePx();
            return new PointF(
                worldCenterX,
                PositionPx.Y + vis.Height * 0.5f);
        },
        new PointF(horizontalAnchor, 0.5f),
        hard);
        _followLayer = target.SceneLayer;
        _followAxis = 1;
    }

    public void FollowCenteredY(IMovableOnSceneLayer target, float speed = -1f, bool hard = false)
    {
        FollowAtY(target, 0.5f, speed, hard);
    }

    public void FollowAtY(IMovableOnSceneLayer target, float verticalAnchor, float speed = -1f, bool hard = false)
    {
        ArgumentNullException.ThrowIfNull(target);
        ValidateNormalizedAnchor(verticalAnchor, nameof(verticalAnchor));
 
        if (speed > 0f)
            FollowLerpPerSecond = speed;
 
        FollowAt(() =>
        {
            var layer = target.SceneLayer;
            var pos = target.GetPosition();
 
            float worldCenterY;
            if (target.PositionSpace == MovementSpace.Grid)
            {
                var anchor = layer.GridToWorldPx(new PointF(pos.X, pos.Y));
                worldCenterY = anchor.Y + layer.TileHeight * 0.5f;
            }
            else
            {
                worldCenterY = pos.Y;
            }
 
            var vis = GetVisibleWorldSizePx();
            return new PointF(
                PositionPx.X + vis.Width * 0.5f,
                worldCenterY);
        },
        new PointF(0.5f, verticalAnchor),
        hard);
        _followLayer = target.SceneLayer;
        _followAxis = 2;
    }

    public void ClearFollow()
    {
        _followAxis = 0;
        _followLayer = null;
        _followWorldPx = null;
        _followAnchor = new PointF(0.5f, 0.5f);
        _panTargetUpperLeftPx = null;
        _hardFollow = false;
    }
 
    #endregion Camera movement methods
 
    internal void Update(float dtSeconds)
    {
        // 1) Explicit pan-to-UL (PanTo) takes priority over center-follow.
        if (_panTargetUpperLeftPx is { } panTarget)
        {
            var clamped = ClampToWorldBounds(panTarget);
 
            if (_hardFollow || _panLerpPerSecond <= 0f)
            {
                PositionPx = clamped;
                _panTargetUpperLeftPx = null;
            }
            else
            {
                float t = 1f - (float)Math.Exp(-_panLerpPerSecond * Math.Max(0f, dtSeconds));
                var newPos = new PointF(
                    PositionPx.X + (clamped.X - PositionPx.X) * t,
                    PositionPx.Y + (clamped.Y - PositionPx.Y) * t);
 
                PositionPx = newPos;
 
                // Close enough → snap and finish.
                if (Math.Abs(newPos.X - clamped.X) < 0.5f &&
                    Math.Abs(newPos.Y - clamped.Y) < 0.5f)
                {
                    PositionPx = clamped;
                    _panTargetUpperLeftPx = null;
                }
            }
 
            // If we're actively panning, don't also run center-follow this frame.
            if (_panTargetUpperLeftPx is not null)
                return;
        }
 
        // 2) Center-follow / dead-zone logic.
        if (_followWorldPx is null)
            return;
 
        var target = _followWorldPx();
        if (TopologyLayer is { } layer && (layer.WrapHorizontally || layer.WrapVertically))
        {
            var visible = GetVisibleWorldSizePx();
            var followReference = new PointF(
                PositionPx.X + visible.Width * _followAnchor.X,
                PositionPx.Y + visible.Height * _followAnchor.Y);
            var period = layer.GetPeriod();
            if (_followAxis == 1)
            {
                target = NearestWrappedByAxis(period, target, followReference, followX: true);
                target.Y = followReference.Y;
            }
            else if (_followAxis == 2)
            {
                target = NearestWrappedByAxis(period, target, followReference, followX: false);
                target.X = followReference.X;
            }
            else
            {
                target = period.Nearest(target, followReference);
            }
        }
        var desiredUL = DesiredUpperLeftToContainTarget(target);
        if (_hardFollow || FollowLerpPerSecond <= 0f)
        {
            PositionPx = ClampToWorldBounds(desiredUL);
        }
        else
        {
            float t = 1f - (float)Math.Exp(-FollowLerpPerSecond * Math.Max(0f, dtSeconds));
            var clamped = ClampToWorldBounds(desiredUL);
            PositionPx = new PointF(
                PositionPx.X + (clamped.X - PositionPx.X) * t,
                PositionPx.Y + (clamped.Y - PositionPx.Y) * t);
        }
    }
 
    #region private methods
 
    private PointF DesiredUpperLeftToContainTarget(PointF targetWorldPx)
    {
        var vis = GetVisibleWorldSizePx();
        if (DeadZonePx == Rectangle.Empty)
            return new PointF(
                targetWorldPx.X - vis.Width * _followAnchor.X,
                targetWorldPx.Y - vis.Height * _followAnchor.Y);
 
        var viewWorld = new RectangleF(PositionPx.X, PositionPx.Y, vis.Width, vis.Height);
        var dzWorld = new RectangleF(viewWorld.X + DeadZonePx.X,
                                     viewWorld.Y + DeadZonePx.Y,
                                     DeadZonePx.Width, DeadZonePx.Height);
 
        if (dzWorld.Contains(targetWorldPx))
            return PositionPx;
 
        float newX = PositionPx.X;
        float newY = PositionPx.Y;
 
        if (targetWorldPx.X < dzWorld.Left)
            newX -= dzWorld.Left - targetWorldPx.X;
 
        if (targetWorldPx.X > dzWorld.Right)
            newX += targetWorldPx.X - dzWorld.Right;
 
        if (targetWorldPx.Y < dzWorld.Top)
            newY -= dzWorld.Top - targetWorldPx.Y;
 
        if (targetWorldPx.Y > dzWorld.Bottom)
            newY += targetWorldPx.Y - dzWorld.Bottom;
 
        return new PointF(newX, newY);
    }
 
    private static PointF NearestWrappedByAxis(LayerPeriod period, PointF point, PointF reference, bool followX)
    {
        var delta = new PointF(reference.X - point.X, reference.Y - point.Y);
        var coefficients = period.Coefficients(delta);
        int baseColumn = (int)Math.Round(coefficients.X);
        int baseRow = (int)Math.Round(coefficients.Y);
 
        int minColumn = period.WrapColumns ? baseColumn - 4 : 0;
        int maxColumn = period.WrapColumns ? baseColumn + 4 : 0;
        int minRow = period.WrapRows ? baseRow - 4 : 0;
        int maxRow = period.WrapRows ? baseRow + 4 : 0;
 
        var best = period.Nearest(point, reference);
        float bestAxisDistance = followX ? Math.Abs(best.X - reference.X) : Math.Abs(best.Y - reference.Y);
        float bestDistanceSquared = (best.X - reference.X) * (best.X - reference.X) + (best.Y - reference.Y) * (best.Y - reference.Y);
 
        for (int c = minColumn; c <= maxColumn; c++)
            for (int r = minRow; r <= maxRow; r++)
            {
                var offset = period.Offset(c, r);
                var candidate = new PointF(point.X + offset.X, point.Y + offset.Y);
                float axisDistance = followX ? Math.Abs(candidate.X - reference.X) : Math.Abs(candidate.Y - reference.Y);
                float distanceSquared = (candidate.X - reference.X) * (candidate.X - reference.X) +
                                        (candidate.Y - reference.Y) * (candidate.Y - reference.Y);
                if (axisDistance < bestAxisDistance ||
                    (axisDistance == bestAxisDistance && distanceSquared < bestDistanceSquared))
                {
                    best = candidate;
                    bestAxisDistance = axisDistance;
                    bestDistanceSquared = distanceSquared;
                }
            }
 
        return best;
    }
 
    private PointF ClampToWorldBounds(PointF ul)
    {
        if (WorldBoundsPx == RectangleF.Empty)
            return ul;
 
        var vis = GetVisibleWorldSizePx();
        if (TopologyLayer is { } layer && (layer.WrapHorizontally || layer.WrapVertically))
        {
            var period = layer.GetPeriod();
            var position = period.Coefficients(ul);
            PointF[] Corners(RectangleF rect) => new[] {
                period.Coefficients(new(rect.Left, rect.Top)), period.Coefficients(new(rect.Right, rect.Top)),
                period.Coefficients(new(rect.Left, rect.Bottom)), period.Coefficients(new(rect.Right, rect.Bottom)) };
            var bounds = Corners(WorldBoundsPx);
            var viewport = Corners(new(0, 0, vis.Width, vis.Height));
            float lowX = bounds.Min(p => p.X) - viewport.Min(p => p.X);
            float lowY = bounds.Min(p => p.Y) - viewport.Min(p => p.Y);
            float highX = Math.Max(lowX, bounds.Max(p => p.X) - viewport.Max(p => p.X));
            float highY = Math.Max(lowY, bounds.Max(p => p.Y) - viewport.Max(p => p.Y));
            return period.Offset(layer.WrapHorizontally ? position.X : Math.Clamp(position.X, lowX, highX),
                layer.WrapVertically ? position.Y : Math.Clamp(position.Y, lowY, highY));
        }
        float minX = WorldBoundsPx.Left;
        float minY = WorldBoundsPx.Top;
        float maxX = WorldBoundsPx.Right - vis.Width;
        float maxY = WorldBoundsPx.Bottom - vis.Height;
 
        if (maxX < minX)
            maxX = minX;
 
        if (maxY < minY)
            maxY = minY;
 
        return new PointF(
            Math.Clamp(ul.X, minX, maxX),
            Math.Clamp(ul.Y, minY, maxY));
    }
 
    private static void ValidateViewportAnchor(PointF viewportAnchor, string paramName)
    {
        ValidateNormalizedAnchor(viewportAnchor.X, paramName);
        ValidateNormalizedAnchor(viewportAnchor.Y, paramName);
    }
 
    private static void ValidateNormalizedAnchor(float value, string paramName)
    {
        if (!float.IsFinite(value) || value < 0f || value > 1f)
            throw new ArgumentOutOfRangeException(paramName, value, "Camera follow anchors must be finite values from 0 through 1.");
    }

    private static PointF GetCenteredTile(SceneLayer layer, Vector2 gridPos)
    {
        var anchor = layer.GridToWorldPx(new PointF(gridPos.X, gridPos.Y));
        return new PointF(
            anchor.X + layer.TileWidth * 0.5f,
            anchor.Y + layer.TileHeight * 0.5f);
    }
 
    #endregion private methods
}