#ifndef OERSTED_MESH_H
#define OERSTED_MESH_H

#include <algorithm>
#include <fstream>
#include <numeric>
#include <set>

#include "Sketch.hpp"

#include "BoundaryConstraint.h"
#include "Edge.h"
#include "InsertionQueuer.h"
#include "Point.h"
#include "DartTriangle.h"

enum class LocateTriangleResult {
    Interior, Exterior, Boundary, Point // TODO: Enumerate cases in function when triangle is located by a point near the boundary
};

enum class InsertPointResult {
    Success, Midpoint, Duplicate, Failure
};

class Mesh { // TODO: Namespaces. Also, need to rename a bunch of things to be more consistent and clear w.r.t. how various arrays are accessed (e.g. by edge/dart index versus plain index)
public:
    Mesh(Sketch &s);

    friend class BoundaryConstraint;
    friend class CircumcenterQueuer;
    friend class MidpointQueuer;

    double MinimumElementQuality = 0.0;
    double MinimumElementSize = 0.0;
    double MaximumElementSize = DBL_MAX;

    bool are_intersecting(size_t ei, size_t ej) const;

    bool edges_are_valid() const;

    bool in_triangle(Point const p, size_t ei) const;

    bool is_constrained(size_t ei) const { return Edges[ei].Constraint != 0; };

    bool is_encroached(Point const p, size_t ei) const;

    bool is_locally_optimal(size_t ei) const;

    bool is_protruding(size_t ei) const;

    bool is_valid(size_t ei) const;

    bool orientation(size_t ei) const { return Edges[ei].Orientation; };

    bool refine();

    bool refine_once();

    double circumradius(size_t ei) const;

    double length(size_t ei) const;

    double shortest_edge_length(size_t ei) const;

    size_t next(size_t ei) const { return Edges[ei].Next; };

    size_t node(size_t ei) const { return Edges[ei].Node; };

    size_t node(Edge const e) const { return e.Node; };

    size_t num_points() const { return Points.size(); };

    size_t num_edges() const;

    size_t num_triangles() const { return Triangles.size(); };

    size_t prev(size_t ei) const { return Edges[ei].Prev; };

    size_t size_dart_constraints() const {return DartConstraints.size(); };

    size_t size_edges() const { return Edges.size(); };

    size_t size_points() const { return Points.size(); };

    size_t size_triangles() const { return Triangles.size(); };

    size_t size_contours() const { return Contours.size(); };

    size_t twin(size_t ei) const { return Edges[ei].Twin; };

    void add_to_queue(std::unique_ptr<InsertionQueuer> ic) { Queue.push_back(std::move(ic)); };

    void create();

    void save_as(std::string path, std::string file_name) const;

    // TODO: rename these methods something like, dart_constraint_from_edge_index, curve_from_edge_index
    DartConstraint const constraint(size_t ei) const { return DartConstraints[Edges[ei].Constraint]; };

    std::shared_ptr<Curve const> constraint_curve(size_t ei) const { return DartConstraints[Edges[ei].Constraint].curve(); };

    std::shared_ptr<BoundaryConstraint> boundary_constraint(std::shared_ptr<Curve const> const &c) const;

    DartConstraint const dart_constraint(size_t i) const { return DartConstraints[i]; };

    DartTriangle const &triangle(size_t i) const { return Triangles[i]; };

    Point circumcenter(size_t ei) const;

    Point const &base(Edge const &e) const { return Points[e.Node]; };

    Point const &base(size_t i) const { return Points[node(i)]; };

    Point const &point(size_t i) const { return Points[i]; };

    Point const &point(Edge const &e) const { return Points[e.Node]; };

    Point const &tip(Edge const &e) const { return Points[next(e).Node]; };

    Point const &tip(size_t i) const { return Points[node(next(i))]; };

    Point midpoint(size_t e) { return midpoint(Edges[e]); };

    Point midpoint(Edge const e) const {
        Point const &p0 = base(e);
        Point const &p1 = tip(e);

        return Point((p0.X + p1.X) / 2.0, (p0.Y + p1.Y) / 2.0);
    }

    Edge const &edge(size_t i) const { return Edges[i]; };

    Edge const &next(Edge const &e) const { return Edges[e.Next]; };

    Edge const &prev(Edge const &e) const { return Edges[e.Prev]; };

    Edge const &twin(Edge const &e) const { return Edges[e.Twin]; };

    Edge const &edge_from_triangle_index(size_t i) const { return Edges[Triangles[i].Edge]; }; // TODO: Rename to triangle_dart

    Edge const &edge_from_triangle(DartTriangle const &dt) { return Edges[dt.Edge]; };

    std::array<size_t,3> nodes_from_triangle(DartTriangle const & dt) {
        Edge const &e = edge_from_triangle(dt);

        std::array<size_t,3> n;

        n[0] = e.Node;
        n[1] = next(e).Node;
        n[2] = prev(e).Node;

        return n;
    };

    LocateTriangleResult locate_triangle(Point const p, size_t &ei) const;

    LocateTriangleResult locate_triangle(Point const p) const {
        size_t ei = Edges.size() - 1;
        return locate_triangle(p, ei);
    };

    AddToQueueResult add_circumcenter_to_queue(size_t dart);

    AddToQueueResult add_point_to_queue(Point const p, size_t dart);

    AddToQueueResult add_point_to_queue(Point const p) { return add_point_to_queue(p, Edges.size() - 1); };

protected:
    std::shared_ptr<Contour const> Boundary;
    std::vector<std::shared_ptr<Contour const>> Contours;
    std::vector<std::shared_ptr<BoundaryConstraint>> BoundaryConstraints;

    std::vector<Point> Points;
    std::vector<Edge> Edges;
    std::vector<DartConstraint> DartConstraints;
    std::vector<DartTriangle> Triangles;

    std::vector<std::unique_ptr<InsertionQueuer>> Queue;

private:
    bool find_attached(Point const p, size_t &ei);

    bool recursive_swap(size_t ei);

    bool swap(size_t ei);

    size_t new_edges(size_t num_new) {
        for (size_t i = 0; i != num_new; ++i) {
            Edges.emplace_back(Edges.size());
            Edges.back().Constraint = 0;
        }
        return Edges.size();
    }

    DartConstraint &new_dart_constraint(DartConstraint &dc) {
        return new_dart_constraint(dc.S0, dc.S1, dc.boundary_constraint());
    }

    DartConstraint &new_dart_constraint(double s0, double s1, std::shared_ptr<BoundaryConstraint> bc) {
        bc->add_dart_constraint(DartConstraints.size());
        DartConstraints.emplace_back(s0, s1, bc, DartConstraints.size());
        return DartConstraints.back();
    }

    Edge &new_edge(size_t p, size_t c, bool dir) {
        Edges.emplace_back(p, Edges.size(), c, dir);
        return Edges.back();
    }

    void create_boundary_polygon();

    void element_quality(std::vector<double> &radii, std::vector<double> &quality);

    void get_triangles();

    void insert_from_queue();

    void insert_internal_boundaries();

    void mark_triangles();

    void refine_once(std::vector<size_t> index, std::vector<double> circumradius, std::vector<double> quality);

    void sort_constraints();

    void sort_permutation_ascending(std::vector<double> &value, std::vector<size_t> &index) const;

    void sort_permutation_descending(std::vector<double> &values, std::vector<size_t> &index) const;

    void split_edge(size_t ei);

    void split_encroached_edges();

    void triangulate_boundary_polygon();

    std::vector<size_t> get_encroached_edges(Point const p, size_t edge);

    InsertPointResult insert_point(Point const p, size_t ei);

    InsertPointResult insert_midpoint(size_t ei);
};

#endif //OERSTED_MESH_H