/*
 * Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <LibGfx/Point.h>
#include <LibGfx/Rect.h>
#include <LibGfx/Triangle.h>

namespace Gfx {

template<typename T>
class Quad {
public:
    Quad(Point<T> p1, Point<T> p2, Point<T> p3, Point<T> p4)
        : m_p1(p1)
        , m_p2(p2)
        , m_p3(p3)
        , m_p4(p4)
    {
    }

    Quad(Rect<T> const& rect)
        : Quad(rect.top_left(), rect.top_right(), rect.bottom_right(), rect.bottom_left())
    {
    }

    Point<T> const& p1() const { return m_p1; }
    Point<T> const& p2() const { return m_p2; }
    Point<T> const& p3() const { return m_p3; }
    Point<T> const& p4() const { return m_p4; }

    Rect<T> bounding_rect() const
    {
        auto top = min(min(m_p1.y(), m_p2.y()), min(m_p3.y(), m_p4.y()));
        auto right = max(max(m_p1.x(), m_p2.x()), max(m_p3.x(), m_p4.x()));
        auto bottom = max(max(m_p1.y(), m_p2.y()), max(m_p3.y(), m_p4.y()));
        auto left = min(min(m_p1.x(), m_p2.x()), min(m_p3.x(), m_p4.x()));
        return { left, top, right - left, bottom - top };
    }

    bool contains(Point<T> point) const
    {
        // FIXME: There's probably a smarter way to do this.
        return Triangle(m_p1, m_p2, m_p3).contains(point)
            || Triangle(m_p1, m_p3, m_p4).contains(point)
            || Triangle(m_p2, m_p4, m_p1).contains(point)
            || Triangle(m_p2, m_p4, m_p3).contains(point);
    }

    bool operator==(Quad<T> const&) const = default;

private:
    Point<T> m_p1;
    Point<T> m_p2;
    Point<T> m_p3;
    Point<T> m_p4;
};

}
