Stanza.h

// SPDX-License-Identifier: GPL-2.0-only

#pragma once

#include <filesystem>
#include <functional>
#include <iostream>
#include <numeric>
#include <set>
#include <string>
#include <vector>

#include "Pattern.h"
#include "Person.h"

namespace SlKernCVS {

class Stanza {
public:
    using TranslateEmail = std::function<std::string (std::string_view sv)>;
    using Maintainers = std::vector<Person>;

    Stanza() = default;
    Stanza(std::string name) : m_name(std::move(name)) {}
    Stanza(std::string n, std::string name, std::string email)
        : m_name(std::move(n)), m_maintainers{Person(RoleType::Maintainer, std::move(name),
                                 std::move(email))} { }

    Stanza(const Stanza &) = delete;
    Stanza(Stanza &&) = default;

    unsigned match_path(const std::filesystem::path &path) const {
        return std::accumulate(m_patterns.cbegin(), m_patterns.cend(), 0u,
                       [&path](unsigned m, const Pattern &p) {
            return std::max(m, p.match(path));
        });
    }

    void add_maintainer_and_store(std::string_view maintainer,
                      std::set<std::string> &suse_users,
                      const TranslateEmail &translateEmail) {
        if (auto m = Person::parsePerson(maintainer, RoleType::Maintainer)) {
            suse_users.insert(m->userName());
            // TODO
            m->setEmail(translateEmail(m->email()));
            // END TODO
            m_maintainers.push_back(std::move(*m));
        } else
            std::cerr << "MAINTAINERS: contact " << maintainer <<
                     " cannot be parsed into name and email!\n";
    }

    void add_backporter(const std::string &name, std::string_view email,
                unsigned cnt, const TranslateEmail &translateEmail) {
        m_maintainers.push_back(Person(RoleType::Maintainer, name,
                           /*TODO*/ translateEmail(email), cnt));
    }

    void add_maintainer_if(std::string_view maintainer,
                   const std::set<std::string> &suse_users,
                   const TranslateEmail &translateEmail) {
        if (auto m = Person::parsePerson(maintainer, RoleType::Upstream)) {
            // TODO
            m->setEmail(translateEmail(m->email()));
            // END TODO
            if (suse_users.contains(m->userName()))
                m_maintainers.push_back(std::move(*m));
        } else
            std::cerr << "Upstream MAINTAINERS: contact " << maintainer <<
                     " cannot be parsed into name and email!\n";
    }

    void add_comment(std::string comment) {
        m_comments.emplace_back(std::move(comment));
    }

    bool add_pattern(std::string pattern) {
        auto p = Pattern::create(std::move(pattern));
        if (!p)
            return false;
        m_patterns.push_back(std::move(*p));
        return true;
    }

    bool empty() const {
        return m_name.empty() || m_maintainers.empty() || m_patterns.empty();
    }

    const Maintainers &maintainers() const { return m_maintainers; }

    auto &comments() const { return m_comments; }

    const std::string &name() const { return m_name; }
private:
    std::string m_name;
    Maintainers m_maintainers;
    std::vector<std::string> m_comments;
    std::vector<Pattern> m_patterns;
};

} // namespace