#include <algorithm>
#include <cmath>
#include "RectConvex.h"

bool cmp(const std::pair<int, int>& a, const std::pair<int, int>& b) {
    if (a.first == b.first) {
        return a.second < b.second;
    } else {
        return a.first < b.first;
    }
}

std::vector<std::pair<double, double>> RectConvex::getMinRect(std::vector<std::pair<int, int>>& contour) {
    std::sort(contour.begin(), contour.end(), cmp);

    std::pair a(contour[0].first, contour[0].second);
    std::pair b(contour[contour.size() - 1].first, contour[contour.size() - 1].second);
    std::pair<double, double> c;
    std::pair<double, double> d;

    std::vector<int> base_line;
    std::vector<int> perpendicular_1;
    std::vector<int> perpendicular_2;
    std::vector<int> parallel_1;
    std::vector<int> parallel_2;

    base_line.emplace_back(b.second - a.second);
    base_line.emplace_back(a.first - b.first);
    base_line.emplace_back(a.second * b.first - b.second * a.first);

    double max = 0;
    double min = 0;
    for (int i = 1; i < contour.size() - 1; ++i) {
        int a_ = contour[i].first;
        int b_ = contour[i].second;
        double dist = ((double) (base_line[0] * a_ + base_line[1] * b_ + base_line[2])) / sqrt(a_ * a_ + b_ * b_);
        if (dist > max) {
            max = dist;
            c = contour[i];
        } else if (dist < min) {
            min = dist;
            d = contour[i];
        }
    }

    int tmp_coef1 = b.first - a.first;
    int tmp_coef2 = b.second - a.second;
    perpendicular_1.emplace_back(tmp_coef1);
    perpendicular_1.emplace_back(tmp_coef2);
    perpendicular_1.emplace_back((-1) * (tmp_coef1 * a.first + tmp_coef2 * a.second));

    perpendicular_2.emplace_back(tmp_coef1);
    perpendicular_2.emplace_back(tmp_coef2);
    perpendicular_2.emplace_back((-1) * (tmp_coef1 * b.first + tmp_coef2 * b.second));

    parallel_1.emplace_back(base_line[0]);
    parallel_1.emplace_back(base_line[1]);
    parallel_1.emplace_back((-1) * (base_line[0] * c.first + base_line[1] * c.second));

    parallel_2.emplace_back(base_line[0]);
    parallel_2.emplace_back(base_line[1]);
    parallel_2.emplace_back((-1) * (base_line[0] * d.first + base_line[1] * d.second));

    std::vector<std::pair<double, double>> res;

    //parallel_1 and perpendicular_1
    {
        int A1 = parallel_1[0];
        int A2 = perpendicular_1[0];
        int B1 = parallel_1[1];
        int B2 = perpendicular_1[1];
        int C1 = parallel_1[2];
        int C2 = perpendicular_1[2];

        double x_angle = ((double) (B1 * C2 - B2 * C1)) / (B2 * A1 - A2 * B1);
        double y_angle = ((double) (A2 * C1 - A1 * C2)) / (B2 * A1 - A2 * B1);
        res.emplace_back(std::pair(x_angle, y_angle));
    }

    //parallel_1 and perpendicular_2
    {
        int A1 = parallel_1[0];
        int A2 = perpendicular_2[0];
        int B1 = parallel_1[1];
        int B2 = perpendicular_2[1];
        int C1 = parallel_1[2];
        int C2 = perpendicular_2[2];

        double x_angle = ((double) (B1 * C2 - B2 * C1)) / (B2 * A1 - A2 * B1);
        double y_angle = ((double) (A2 * C1 - A1 * C2)) / (B2 * A1 - A2 * B1);
        res.emplace_back(std::pair(x_angle, y_angle));
    }

    //parallel_2 and perpendicular_1
    {
        int A1 = parallel_2[0];
        int A2 = perpendicular_1[0];
        int B1 = parallel_2[1];
        int B2 = perpendicular_1[1];
        int C1 = parallel_2[2];
        int C2 = perpendicular_1[2];

        double x_angle = ((double) (B1 * C2 - B2 * C1)) / (B2 * A1 - A2 * B1);
        double y_angle = ((double) (A2 * C1 - A1 * C2)) / (B2 * A1 - A2 * B1);
        res.emplace_back(std::pair(x_angle, y_angle));
    }

    //parallel_2 and perpendicular_2
    {
        int A1 = parallel_2[0];
        int A2 = perpendicular_2[0];
        int B1 = parallel_2[1];
        int B2 = perpendicular_2[1];
        int C1 = parallel_2[2];
        int C2 = perpendicular_2[2];

        double x_angle = ((double) (B1 * C2 - B2 * C1)) / (B2 * A1 - A2 * B1);
        double y_angle = ((double) (A2 * C1 - A1 * C2)) / (B2 * A1 - A2 * B1);
        res.emplace_back(std::pair(x_angle, y_angle));
    }

    return res;
}