#include "labeller.h"
#include "settings.h"
#include <fstream>


namespace backend {
    struct labeller_impl {
        std::vector<std::string> labels;
        std::vector<label> annotations;
        // Bool in undo/redo buffers is whether was applied or deleted
        std::vector<std::pair<bool, label>> undoBuffer;
        std::vector<std::pair<bool, label>> redoBuffer;
        std::filesystem::path savepath;
    };

    labeller::labeller(const std::filesystem::path& savepath) {
        data = std::shared_ptr<labeller_impl>(new labeller_impl);
        data->labels = settings::getLabels();
        data->savepath = savepath;
    }

    std::pair<label, label> labeller::getSurrounding(double time) const {
        std::pair<label, label> labs;
        if(!data->annotations.empty()) {
            auto above = data->annotations.rbegin();
            auto below = above;
            auto rit = above;
            while(++rit != data->annotations.rend()) {
                if(rit->time > time && (above->time <= time || rit->time < above->time)) above = rit;
                if(rit->time <= time && (below->time > time || rit->time > below->time)) below = rit;
            }
            if(below->time <= time) labs.first = *below;
            if(above->time > time) labs.second = *above;
        }
        return labs;
    }

    std::vector<std::string> labeller::getLabels() const {
        return data->labels;
    }

    void appLab(std::vector<label>& annotations, label lab) {
        annotations.push_back(lab);
    }

    void labeller::applyLabel(std::string name, double time) {
        label lab(name, time);
        appLab(data->annotations, lab);
        data->undoBuffer.push_back({true, lab});
        data->redoBuffer.clear();
    }

    double abs(double x) {
        if(x < 0) x *= -1;
        return x;
    }

    label delLab(std::vector<label>& annotations, double time) {
        if(annotations.empty()) {
            return label();
        }
        auto closest = annotations.rbegin();
        auto rit = closest;
        while(++rit != annotations.rend()) {
            if(abs(rit->time - time) < abs(closest->time - time)) {
                closest = rit;
            }
        }
        label c(*closest);
        annotations.erase(closest.base());
        return c;
    }

    void labeller::deleteLabel(double time) {
        label deleted = delLab(data->annotations, time);
        data->undoBuffer.push_back({false, deleted});
        data->redoBuffer.clear();
    }

    // Pops action from 'from', applies, and appends to 'to'.
    void handleUndoRedo(std::vector<std::pair<bool, label>>& from, std::vector<std::pair<bool, label>>& to, std::vector<label>& annotations) {
        if(! from.empty()) {
            auto elem = from.back();
            from.pop_back();
            if(elem.first) { // It was applied, so we must unapply
                delLab(annotations, elem.second.time);
            } else {
                appLab(annotations, elem.second);
            }
            to.push_back({! elem.first, elem.second});
        }
    }

    void labeller::undo() {
        handleUndoRedo(data->undoBuffer, data->redoBuffer, data->annotations);
    }

    void labeller::redo() {
        handleUndoRedo(data->redoBuffer, data->undoBuffer, data->annotations);
    }

    bool compareLabels(label l1, label l2) {
        return (l1.time < l2.time);
    }

    void labeller::save() const {
        std::ofstream out;
        out.open(data->savepath);
        std::vector<label> a(data->annotations);
        std::sort(a.begin(), a.end(), compareLabels);
        for(label l : a) {
            out << l.name << "," << l.time << std::endl;
        }
        out.close();
    }
}