/*
 * Copyright (C) 2024 Emeric Poupon
 *
 * This file is part of LMS.
 *
 * LMS is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * LMS is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <map>
#include <vector>
#include <gtest/gtest.h>

#include "TestTagReader.hpp"
#include "Parser.hpp"

namespace lms::metadata
{
    TEST(Parser, generalTest)
    {
        Parser parser;
        TestTagReader testTags{
            {
                { TagType::AcoustID, { "e987a441-e134-4960-8019-274eddacc418" } },
                { TagType::Album, { "MyAlbum" } },
                { TagType::AlbumSortOrder, { "MyAlbumSortName" } },
                { TagType::Artist, { "MyArtist1 & MyArtist2" } },
                { TagType::Artists, { "MyArtist1", "MyArtist2" } },
                { TagType::ArtistSortOrder, { "MyArtist1SortName", "MyArtist2SortName" } },
                { TagType::AlbumArtist, { "MyAlbumArtist1 & MyAlbumArtist2" } },
                { TagType::AlbumArtists, { "MyAlbumArtist1", "MyAlbumArtist2" } },
                { TagType::AlbumArtistsSortOrder, { "MyAlbumArtist1SortName", "MyAlbumArtist2SortName" } },
                { TagType::Composer, { "MyComposer1", "MyComposer2" } },
                { TagType::ComposerSortOrder, { "MyComposerSortOrder1", "MyComposerSortOrder2" } },
                { TagType::Conductor, { "MyConductor1", "MyConductor2" } },
                { TagType::Copyright, { "MyCopyright" } },
                { TagType::CopyrightURL, { "MyCopyrightURL" } },
                { TagType::Date, { "2020/03/04" } },
                { TagType::DiscNumber, { "2" } },
                { TagType::DiscSubtitle, { "MySubtitle" } },
                { TagType::Genre, { "Genre1", "Genre2" } },
                { TagType::Grouping, { "Grouping1", "Grouping2" } },
                { TagType::Media, { "CD" } },
                { TagType::Mixer, { "MyMixer1", "MyMixer2" } },
                { TagType::Mood, { "Mood1", "Mood2" } },
                { TagType::MusicBrainzArtistID, { "9d2e0c8c-8c5e-4372-a061-590955eaeaae", "5e2cf87f-c8d7-4504-8a86-954dc0840229" } },
                { TagType::MusicBrainzTrackID, { "0afb190a-6735-46df-a16d-199f48206e4a" } },
                { TagType::MusicBrainzReleaseArtistID, { "6fbf097c-1487-43e8-874b-50dd074398a7", "5ed3d6b3-2aed-4a03-828c-3c4d4f7406e1" } },
                { TagType::MusicBrainzReleaseID, { "3fa39992-b786-4585-a70e-85d5cc15ef69" } },
                { TagType::MusicBrainzReleaseGroupID, { "5b1a5a44-8420-4426-9b86-d25dc8d04838" } },
                { TagType::MusicBrainzRecordingID, { "bd3fc666-89de-4ac8-93f6-2dbf028ad8d5" } },
                { TagType::Producer, { "MyProducer1", "MyProducer2" } },
                { TagType::Remixer, { "MyRemixer1", "MyRemixer2" } },
                { TagType::RecordLabel, { "Label1", "Label2" } },
                { TagType::Language, { "Language1", "Language2" } },
                { TagType::Lyricist, { "MyLyricist1", "MyLyricist2" } },
                { TagType::OriginalReleaseDate, { "2019/02/03" } },
                { TagType::ReleaseType, {"Album", "Compilation"} },
                { TagType::ReplayGainTrackGain, {"-0.33"} },
                { TagType::ReplayGainAlbumGain, {"-0.5"} },
                { TagType::TrackTitle, {"MyTitle"} },
                { TagType::TrackNumber, { "7" } },
                { TagType::TotalTracks, { "12" } },
                { TagType::TotalDiscs, { "3" } },
            }
            ,
            {
                { "RoleA", { "MyPerformer1ForRoleA", "MyPerformer2ForRoleA" } },
                { "RoleB", { "MyPerformer1ForRoleB", "MyPerformer2ForRoleB" } }
            },
            {
                { "MY_AWESOME_TAG_A", { "MyTagValue1ForTagA", "MyTagValue2ForTagA" } },
                { "MY_AWESOME_TAG_B", { "MyTagValue1ForTagB", "MyTagValue2ForTagB" } }
            }
        };

        static_cast<IParser&>(parser).setUserExtraTags(std::vector<std::string>{ "MY_AWESOME_TAG_A", "MY_AWESOME_TAG_B", "MY_AWESOME_MISSING_TAG" });

        std::unique_ptr<Track> track{ parser.parse(testTags) };

        // Audio properties
        {
            const AudioProperties& audioProperties{ testTags.getAudioProperties() };
            EXPECT_EQ(track->audioProperties.bitrate, audioProperties.bitrate);
            EXPECT_EQ(track->audioProperties.bitsPerSample, audioProperties.bitsPerSample);
            EXPECT_EQ(track->audioProperties.channelCount, audioProperties.channelCount);
            EXPECT_EQ(track->audioProperties.duration, audioProperties.duration);
            EXPECT_EQ(track->audioProperties.sampleRate, audioProperties.sampleRate);
        }

        EXPECT_EQ(track->acoustID, core::UUID::fromString("e987a441-e134-4960-8019-274eddacc418"));
        EXPECT_EQ(track->artistDisplayName, "MyArtist1 & MyArtist2");
        ASSERT_EQ(track->artists.size(), 2);
        EXPECT_EQ(track->artists[0].name, "MyArtist1");
        EXPECT_EQ(track->artists[0].sortName, "MyArtist1SortName");
        EXPECT_EQ(track->artists[0].mbid, core::UUID::fromString("9d2e0c8c-8c5e-4372-a061-590955eaeaae"));
        EXPECT_EQ(track->artists[1].name, "MyArtist2");
        EXPECT_EQ(track->artists[1].sortName, "MyArtist2SortName");
        EXPECT_EQ(track->artists[1].mbid, core::UUID::fromString("5e2cf87f-c8d7-4504-8a86-954dc0840229"));
        ASSERT_EQ(track->composerArtists.size(), 2);
        EXPECT_EQ(track->composerArtists[0].name, "MyComposer1");
        EXPECT_EQ(track->composerArtists[0].sortName, "MyComposerSortOrder1");
        EXPECT_EQ(track->composerArtists[1].name, "MyComposer2");
        EXPECT_EQ(track->composerArtists[1].sortName, "MyComposerSortOrder2");
        ASSERT_EQ(track->conductorArtists.size(), 2);
        EXPECT_EQ(track->conductorArtists[0].name, "MyConductor1");
        EXPECT_EQ(track->conductorArtists[1].name, "MyConductor2");
        EXPECT_EQ(track->copyright, "MyCopyright");
        EXPECT_EQ(track->copyrightURL, "MyCopyrightURL");
        ASSERT_TRUE(track->date.isValid());
        EXPECT_EQ(track->date.year(), 2020);
        EXPECT_EQ(track->date.month(), 3);
        EXPECT_EQ(track->date.day(), 4);
        EXPECT_FALSE(track->hasCover);
        ASSERT_EQ(track->genres.size(), 2);
        EXPECT_EQ(track->genres[0], "Genre1");
        EXPECT_EQ(track->genres[1], "Genre2");
        ASSERT_EQ(track->groupings.size(), 2);
        EXPECT_EQ(track->groupings[0], "Grouping1");
        EXPECT_EQ(track->groupings[1], "Grouping2");
        ASSERT_EQ(track->labels.size(), 2);
        EXPECT_EQ(track->labels[0], "Label1");
        EXPECT_EQ(track->labels[1], "Label2");
        ASSERT_EQ(track->languages.size(), 2);
        EXPECT_EQ(track->languages[0], "Language1");
        EXPECT_EQ(track->languages[1], "Language2");
        ASSERT_EQ(track->lyricistArtists.size(), 2);
        EXPECT_EQ(track->lyricistArtists[0].name, "MyLyricist1");
        EXPECT_EQ(track->lyricistArtists[1].name, "MyLyricist2");
        ASSERT_TRUE(track->mbid.has_value());
        EXPECT_EQ(track->mbid.value(), core::UUID::fromString("0afb190a-6735-46df-a16d-199f48206e4a"));
        ASSERT_EQ(track->mixerArtists.size(), 2);
        EXPECT_EQ(track->mixerArtists[0].name, "MyMixer1");
        EXPECT_EQ(track->mixerArtists[1].name, "MyMixer2");
        ASSERT_EQ(track->moods.size(), 2);
        EXPECT_EQ(track->moods[0], "Mood1");
        EXPECT_EQ(track->moods[1], "Mood2");
        ASSERT_TRUE(track->originalDate.isValid());
        EXPECT_EQ(track->originalDate.year(), 2019);
        EXPECT_EQ(track->originalDate.month(), 2);
        EXPECT_EQ(track->originalDate.day(), 3);
        ASSERT_TRUE(track->originalYear.has_value());
        EXPECT_EQ(track->originalYear.value(), 2019);
        ASSERT_TRUE(track->performerArtists.contains("Rolea"));
        ASSERT_EQ(track->performerArtists["Rolea"].size(), 2);
        EXPECT_EQ(track->performerArtists["Rolea"][0].name, "MyPerformer1ForRoleA");
        EXPECT_EQ(track->performerArtists["Rolea"][1].name, "MyPerformer2ForRoleA");
        ASSERT_EQ(track->performerArtists["Roleb"].size(), 2);
        EXPECT_EQ(track->performerArtists["Roleb"][0].name, "MyPerformer1ForRoleB");
        EXPECT_EQ(track->performerArtists["Roleb"][1].name, "MyPerformer2ForRoleB");
        ASSERT_TRUE(track->position.has_value());
        EXPECT_EQ(track->position.value(), 7);
        ASSERT_EQ(track->producerArtists.size(), 2);
        EXPECT_EQ(track->producerArtists[0].name, "MyProducer1");
        EXPECT_EQ(track->producerArtists[1].name, "MyProducer2");
        ASSERT_TRUE(track->recordingMBID.has_value());
        EXPECT_EQ(track->recordingMBID.value(), core::UUID::fromString("bd3fc666-89de-4ac8-93f6-2dbf028ad8d5"));
        ASSERT_TRUE(track->replayGain.has_value());
        EXPECT_FLOAT_EQ(track->replayGain.value(), -0.33);
        ASSERT_EQ(track->remixerArtists.size(), 2);
        EXPECT_EQ(track->remixerArtists[0].name, "MyRemixer1");
        EXPECT_EQ(track->remixerArtists[1].name, "MyRemixer2");
        EXPECT_EQ(track->title, "MyTitle");
        ASSERT_EQ(track->userExtraTags["MY_AWESOME_TAG_A"].size(), 2);
        EXPECT_EQ(track->userExtraTags["MY_AWESOME_TAG_A"][0], "MyTagValue1ForTagA");
        EXPECT_EQ(track->userExtraTags["MY_AWESOME_TAG_A"][1], "MyTagValue2ForTagA");
        ASSERT_EQ(track->userExtraTags["MY_AWESOME_TAG_B"].size(), 2);
        EXPECT_EQ(track->userExtraTags["MY_AWESOME_TAG_B"][0], "MyTagValue1ForTagB");
        EXPECT_EQ(track->userExtraTags["MY_AWESOME_TAG_B"][1], "MyTagValue2ForTagB");
        ASSERT_TRUE(track->year.has_value());
        EXPECT_EQ(track->year.value(), 2020);

        // Medium
        ASSERT_TRUE(track->medium.has_value());
        EXPECT_EQ(track->medium->media, "CD");
        EXPECT_EQ(track->medium->name, "MySubtitle");
        ASSERT_TRUE(track->medium->position.has_value());
        EXPECT_EQ(track->medium->position.value(), 2);
        ASSERT_TRUE(track->medium->replayGain.has_value());
        EXPECT_FLOAT_EQ(track->medium->replayGain.value(), -0.5);
        ASSERT_TRUE(track->medium->trackCount.has_value());
        EXPECT_EQ(track->medium->trackCount.value(), 12);

        // Release
        ASSERT_TRUE(track->medium->release.has_value());
        EXPECT_EQ(track->medium->release->artistDisplayName, "MyAlbumArtist1 & MyAlbumArtist2");
        ASSERT_EQ(track->medium->release->artists.size(), 2);
        EXPECT_EQ(track->medium->release->artists[0].name, "MyAlbumArtist1");
        EXPECT_EQ(track->medium->release->artists[0].sortName, "MyAlbumArtist1SortName");
        EXPECT_EQ(track->medium->release->artists[0].mbid, core::UUID::fromString("6fbf097c-1487-43e8-874b-50dd074398a7"));
        EXPECT_EQ(track->medium->release->artists[1].name, "MyAlbumArtist2");
        EXPECT_EQ(track->medium->release->artists[1].sortName, "MyAlbumArtist2SortName");
        EXPECT_EQ(track->medium->release->artists[1].mbid, core::UUID::fromString("5ed3d6b3-2aed-4a03-828c-3c4d4f7406e1"));
        ASSERT_TRUE(track->medium->release->mbid.has_value());
        EXPECT_EQ(track->medium->release->mbid.value(), core::UUID::fromString("3fa39992-b786-4585-a70e-85d5cc15ef69"));
        EXPECT_EQ(track->medium->release->groupMBID.value(), core::UUID::fromString("5b1a5a44-8420-4426-9b86-d25dc8d04838"));
        EXPECT_EQ(track->medium->release->mediumCount, 3);
        EXPECT_EQ(track->medium->release->name, "MyAlbum");
        EXPECT_EQ(track->medium->release->sortName, "MyAlbumSortName");
        {
            std::vector<std::string> expectedReleaseTypes{ "Album", "Compilation" };
            EXPECT_EQ(track->medium->release->releaseTypes, expectedReleaseTypes);
        }
    }

    TEST(Parser, trim)
    {
        const TestTagReader testTags{
            {
                { TagType::Genre, { "Genre1 ", " Genre2", " Genre3 " } },
            }
        };

        std::unique_ptr<Track> track{ Parser{}.parse(testTags) };

        ASSERT_EQ(track->genres.size(), 3);
        EXPECT_EQ(track->genres[0], "Genre1");
        EXPECT_EQ(track->genres[1], "Genre2");
        EXPECT_EQ(track->genres[2], "Genre3");
    }

    TEST(Parser, customDelimiters)
    {
        const TestTagReader testTags{
            {
                { TagType::Genre, { "Genre1; Genre2" } },
                { TagType::Language, { " Lang1 ;  Lang2 ; " } },
                { TagType::Artist, { " This /  is ; One Artist \\  Other Artist    " } },
            }
        };

        Parser parser;
        static_cast<IParser&>(parser).setDefaultTagDelimiters(std::vector<std::string>{ " ; " });
        static_cast<IParser&>(parser).setArtistTagDelimiters(std::vector<std::string>{ " \\ ", " / " });
        std::unique_ptr<Track> track{ parser.parse(testTags) };

        ASSERT_EQ(track->genres.size(), 1);
        EXPECT_EQ(track->genres[0], "Genre1; Genre2");
        ASSERT_EQ(track->languages.size(), 2);
        EXPECT_EQ(track->languages[0], "Lang1");
        EXPECT_EQ(track->languages[1], "Lang2");
        ASSERT_EQ(track->artists.size(), 2);
        EXPECT_EQ(track->artists[0].name, "This /  is ; One Artist");
        EXPECT_EQ(track->artists[1].name, "Other Artist");
        EXPECT_EQ(track->artistDisplayName, "This /  is ; One Artist \\  Other Artist");
    }
}