using Plan2D;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ZoomSettings
{
    Plan2DHandler _handler;
    Camera _camera;

    int _layer;

    Vector3 _leftmostPoint = Vector3.positiveInfinity;
    Vector3 _rightmostPoint = Vector3.negativeInfinity;
    Vector3 _upmostPoint = Vector3.negativeInfinity;
    Vector3 _downmostPoint = Vector3.positiveInfinity;

    LineRenderer _lineRenderer;

    Vector3 _centerPos;
    List<Vector3> _corners = new List<Vector3>();
    public ZoomSettings(Camera camera, int layer, Plan2DHandler handler)
    {
        _camera = camera;
        _handler = handler;
        _layer = layer;
    }
    private void CompareHorizontal(Vector3 pos)
    {
        float dotV = Vector3.Dot(pos - _camera.transform.position, _camera.transform.up);

        pos += dotV * -_camera.transform.up;

        float dotRightCurrent = Vector3.Dot(_rightmostPoint - _camera.transform.position, _camera.transform.right);
        float dotLeftCurrent = Vector3.Dot(_leftmostPoint - _camera.transform.position, _camera.transform.right);

        float dotP = Vector3.Dot(pos - _camera.transform.position, _camera.transform.right);

        _rightmostPoint = dotRightCurrent > dotP ? _rightmostPoint : pos;
        _leftmostPoint = dotLeftCurrent < dotP ? _leftmostPoint : pos;
    }
    private void CompareVertical(Vector3 pos)
    {
        float dotH = Vector3.Dot(pos - _camera.transform.position, _camera.transform.right);
        pos += dotH * -_camera.transform.right;

        float doUpCurrent = Vector3.Dot(_upmostPoint - _camera.transform.position, _camera.transform.up);
        float dotDownCurrent = Vector3.Dot(_downmostPoint - _camera.transform.position, _camera.transform.up);

        float dotP = Vector3.Dot(pos - _camera.transform.position, _camera.transform.up);

        _upmostPoint = doUpCurrent > dotP ? _upmostPoint : pos;
        _downmostPoint = dotDownCurrent < dotP ? _downmostPoint : pos;
    }
    public void ComparePosition(Vector3 pos)
    {
        CompareHorizontal(pos);
        CompareVertical(pos);
        UpdateCorners();
    }
    public void ComparePositions(Vector3[] pos)
    {
        foreach (Vector3 p in pos)
        {
            ComparePosition(p);
        }
    }
    public void ResizeCamera()
    {
        float buffer = _handler.ZoomBuffer;

        if (_handler.DebugCameraZoom)
        {
            DebugCameraResize();
        }

        float width = Vector3.Distance(_leftmostPoint, _rightmostPoint) + buffer;
        float height = Vector3.Distance(_downmostPoint, _upmostPoint) + buffer;

        float orthoSize = ((width > height * _camera.aspect) ? (float)width / (float)_camera.pixelWidth * _camera.pixelHeight : height) / 2f;

        _camera.orthographicSize = orthoSize;

        Vector3 centerPos = _centerPos;

        float dis = Vector3.Dot(_camera.transform.position - centerPos, _camera.transform.right);
        _camera.transform.position += -_camera.transform.right * dis;

        float y = Vector3.Dot(_camera.transform.position - centerPos, _camera.transform.up);
        _camera.transform.position += -_camera.transform.up * y;

        _camera.transform.position += -_camera.transform.forward * 150f;
    }
    void UpdateCorners()
    {
        _centerPos = (_leftmostPoint + _rightmostPoint + _downmostPoint + _upmostPoint) / 4f;

        float toCamera = Vector3.Dot(_centerPos - _camera.transform.position, _camera.transform.forward);

        // Calculate the distances to the furthest points in each direction
        float upDistance = Vector3.Dot(_upmostPoint - _camera.transform.position, _camera.transform.up);
        float downDistance = Vector3.Dot(_downmostPoint - _camera.transform.position, -_camera.transform.up);
        float leftDistance = Vector3.Dot(_leftmostPoint - _camera.transform.position, -_camera.transform.right);
        float rightDistance = Vector3.Dot(_rightmostPoint - _camera.transform.position, _camera.transform.right);

        // Calculate the camera's corners based on the center position and the offsets
        _corners = new List<Vector3>()
            {
                _camera.transform.position - _camera.transform.right * leftDistance - _camera.transform.up * downDistance + _camera.transform.forward * toCamera,
                 _camera.transform.position - _camera.transform.right * leftDistance + _camera.transform.up * upDistance + _camera.transform.forward * toCamera,
                 _camera.transform.position + _camera.transform.right * rightDistance + _camera.transform.up * upDistance + _camera.transform.forward * toCamera,
                 _camera.transform.position + _camera.transform.right * rightDistance - _camera.transform.up * downDistance + _camera.transform.forward * toCamera
            };

        _centerPos = (_corners[0] + _corners[1] + _corners[2] + _corners[3]) / 4f;
    }
    private void DebugCameraResize()
    {
        if (_lineRenderer == null)
        {
            string lineRendererName = "LineRenderer Camera Debug"; 
            LineRenderer lineRenderer = _handler.GetLineRendererInstance().GetComponent<LineRenderer>();
            lineRenderer.name = lineRendererName;   
            lineRenderer.transform.parent = _camera.transform;

            _lineRenderer = lineRenderer;
            _handler.AddLineRendererToList(lineRenderer.gameObject, ObjectTypes.Debug);
        }

        _lineRenderer.loop = true;
        _lineRenderer.positionCount = 4;
        _lineRenderer.startColor = Color.blue;
        _lineRenderer.endColor = Color.blue;
        _lineRenderer.gameObject.layer = _layer == -1 ? _lineRenderer.gameObject.layer : _layer;

        _lineRenderer.SetPosition(0, _corners[0]);
        _lineRenderer.SetPosition(1, _corners[1]);
        _lineRenderer.SetPosition(2, _corners[2]);
        _lineRenderer.SetPosition(3, _corners[3]);
    }
}