Song.cpp

#include <algorithm> // std::sort / std::find_if / std::find_if_not
#include <iostream>
#include <string>
#include <vector>

#include "Song.h"

int Song::next_id_ = 1;

namespace
{
    std::string trim_copy(const std::string &s)
    {
        std::string stripHead;
        bool start = false;
        for (int i = 0; i < s.length(); ++i)
        {
            if (start)
            {
                stripHead = stripHead + s[i];
            }
            else
            {
                if (s[i] != ' ')
                {
                    stripHead = stripHead + s[i];
                    start = true;
                }
            }
        }
        std::string stripTail;
        bool end = false;
        for (int i = stripHead.length() - 1; i >= 0; --i)
        {
            if (end)
            {
                stripTail = stripHead[i] + stripTail;
            }
            else
            {
                if (stripHead[i] != ' ')
                {
                    stripTail = stripTail + stripHead[i];
                    end = true;
                }
            }
        }
        return stripTail;
    }
    std::string to_lower_copy(const std::string &s)
    {
        std::string lowerString;
        for (unsigned char c : s)
        {
            lowerString += static_cast<char>(std::tolower(c));
        }
        return lowerString;
    }
    std::string join_tags(const std::vector<std::string> &tags)
    {
        if (tags.empty())
        {
            return "";
        }
        std::string result;
        for (int i = 0; i < tags.size() - 1; ++i)
        {
            result += tags[i];
            result += ", ";
        }
        result += tags.back();
        return result;
    }
}

Song::Song(const std::string &title, const std::string &artist, int duration_sec, int rating)
{
    std::string trimTitle = trim_copy(title);
    std::string trimArtist = trim_copy(artist);
    bool error = false;
    if (trimTitle.empty())
    {
        std::cerr << "[错误] 标题不能为空\n";
        error = true;
    }
    if (trimArtist.empty())
    {
        std::cerr << "[错误] 艺人不能为空\n";
        error = true;
    }
    if (duration_sec <= 0)
    {
        std::cerr << "[错误] 时长必须为正整数（秒）\n";
        error = true;
    }
    if (rating < 1 || rating > 5)
    {
        std::cerr << "[错误] 评分必须在 1...5 之间\n";
        error = true;
    }
    if (error)
    {
        valid_ = false;
        return;
    }
    id_ = next_id_++;
    title_ = trimTitle;
    artist_ = trimArtist;
    duration_sec_ = duration_sec;
    rating_ = rating;
    valid_ = true;
}

bool Song::set_title(const std::string &t)
{
    std::string trimTitle = trim_copy(t);
    if (trimTitle.empty())
    {
        std::cerr << "[提示] 标题不能为空，已忽略本次修改\n";
        return false;
    }
    title_ = trimTitle;
    return true;
}

bool Song::set_artist(const std::string &a)
{
    std::string trimArtist = trim_copy(a);
    if (trimArtist.empty())
    {
        std::cerr << "[提示] 艺人不能为空，已忽略本次修改\n";
        return false;
    }
    artist_ = trimArtist;
    return true;
}

bool Song::set_duration(int sec)
{
    if (sec <= 0)
    {
        std::cerr << "[提示] 时长需为正整数，已忽略本次修改\n";
        return false;
    }
    duration_sec_ = sec;
    return true;
}

bool Song::set_rating(int r)
{
    if (r < 1 || r > 5)
    {
        std::cerr << "[提示] 评分需在 1..5，已忽略本次修改\n";
        return false;
    }
    rating_ = r;
    return true;
}

bool Song::add_tag(const std::string &tag)
{
    std::string trimTag = trim_copy(tag);
    if (trimTag.empty())
    {
        std::cout << "[提示] 空标签已忽略\n";
        return false;
    }
    std::string lowerTag = to_lower_copy(trimTag);
    for (const auto &t : tags_)
    {
        if (to_lower_copy(t) == lowerTag)
        {
            std::cout << "[提示] 标签已存在（忽略大小写）\n";
            return false;
        }
    }
    tags_.push_back(trimTag);
    return true;
}

bool Song::remove_tag(const std::string &tag)
{
    std::string trimTag = trim_copy(tag);
    std::string lowerTag = to_lower_copy(trimTag);
    for (int i = 0; i < tags_.size(); ++i)
    {
        if (to_lower_copy(tags_[i]) == lowerTag)
        {
            tags_.erase(tags_.begin() + i);
            return true;
        }
    }
    std::cout << "[提示] 未找到该标签\n";
    return false;
}

bool Song::matches_keyword(const std::string &kw) const
{
    std::string trimKeyword = trim_copy(kw);
    if (trimKeyword.empty())
        return false;
    std::string keyword = to_lower_copy(trimKeyword);
    if (to_lower_copy(title_).find(keyword) != std::string::npos)
    {
        return true;
    }
    if (to_lower_copy(artist_).find(keyword) != std::string::npos)
    {
        return true;
    }
    for (const auto &t : tags_)
    {
        if (to_lower_copy(t).find(keyword) != std::string::npos)
        {
            return true;
        }
    }
    return false;
}

std::ostream &operator<<(std::ostream &os, const Song &s)
{
    os << "[#" << s.id_ << "] "
       << s.artist_ << " - " << s.title_
       << " (" << s.duration_sec_ << "s) "
       << std::string(s.rating_, '*');
    if (!s.tags_.empty())
    {
        os << "  [tags: " << join_tags(s.tags_) << "]";
    }
    return os;
}

bool operator<(const Song &a, const Song &b)
{
    if (a.rating_ != b.rating_)
    {
        return a.rating_ > b.rating_;
    }
    if (a.title_ != b.title_)
    {
        return a.title_ < b.title_;
    }
    return a.id_ < b.id_;
}