package io.delphiplatform.api.v3.rdb.service.apple.music

import io.delphiplatform.api.v3.model.TrackStateIncludes
import io.delphiplatform.api.v3.model.spotify.ChartTrackMetricsDimension
import io.delphiplatform.api.v3.rdb.entity.apple.music.*
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.mockito.kotlin.mock
import org.mockito.kotlin.verify
import org.mockito.kotlin.whenever
import java.time.LocalDate

class AppleMusicTracksChartsServiceTest {
    private val trackLifetimeService: AppleMusicChartTrackLifetimeService = mock()
    private val artistService: AppleMusicArtistService = mock()

    private val service = AppleMusicTracksChartsService(
            null,
            null,
            trackLifetimeService,
            null,
            artistService
    )

    private val date1 = LocalDate.of(2021, 1, 1)
    private val countryCode1 = "us"

    private val chartId1 = "chart1"
    private val trackId1 = "track1"
    private val isrc1 = "chart1"

    @Test
    fun test_getAppleTrackChartsSearchResults_trackStateIncludes() {
        val trackStateIncludes = setOf(*TrackStateIncludes.values())

        //first - check if TrackStateIncludes enum has changed. If so - would need to update this test
        // (getAppleTrackChartsSearchResults() return fields must repeat passed includes)

        val enumChangedMsg = "TrackStateIncludes enum fields set changed! Please update this test"
        Assertions.assertEquals(5, trackStateIncludes.size, enumChangedMsg)

        Assertions.assertTrue(trackStateIncludes.contains(TrackStateIncludes.LICENSORS), enumChangedMsg)
        Assertions.assertTrue(trackStateIncludes.contains(TrackStateIncludes.LIFETIME_METRICS), enumChangedMsg)
        Assertions.assertTrue(trackStateIncludes.contains(TrackStateIncludes.METRICS), enumChangedMsg)
        Assertions.assertTrue(trackStateIncludes.contains(TrackStateIncludes.PUBLIC_META), enumChangedMsg)
        Assertions.assertTrue(trackStateIncludes.contains(TrackStateIncludes.CHART_META), enumChangedMsg)

        //second - test result object

        val chartTrackEntity = createChartTrackEntity(
                date1,
                trackId1,
                chartId1,
                isrc1,
                countryCode1
        )

        val chartTrackLifetimeEntity = createChartTrackLifetimeEntity(date1, trackId1, chartId1, isrc1, countryCode1)

        val appleMusicChartTrackLifetimeId1 = AppleMusicIsrcAndChartAndTrackIds(chartId1, trackId1, isrc1)

        whenever(
                trackLifetimeService.findChartTrackLifetimeMetricsByIds(
                        mutableListOf(
                                appleMusicChartTrackLifetimeId1
                        )
                )
        ).thenReturn(
            mapOf(
                    appleMusicChartTrackLifetimeId1 to chartTrackLifetimeEntity
            )
        )

        val result = service.getAppleTrackChartsSearchResults(
            trackStateIncludes,
            ChartTrackMetricsDimension.TRACK_ID,
                listOf(chartTrackEntity)
        )

        Assertions.assertNotNull(result)
        Assertions.assertEquals(1, result.size)

        val trackChartSearchResult = result[0]

        //check that all included fields exist in response (and has some correct data)

        Assertions.assertEquals(listOf(*chartTrackLifetimeEntity.track.licensors), trackChartSearchResult.licensors)

        Assertions.assertEquals(chartTrackLifetimeEntity.track.appleMusicTrackId, trackChartSearchResult.publicMeta.trackId)
        Assertions.assertEquals(chartTrackLifetimeEntity.track.isrc, trackChartSearchResult.publicMeta.isrc)
        Assertions.assertEquals(chartTrackLifetimeEntity.track.localizedTracks.size, 1)
        Assertions.assertEquals(chartTrackLifetimeEntity.track.localizedTracks[0].name, trackChartSearchResult.publicMeta.name)

        Assertions.assertEquals(chartTrackLifetimeEntity.chart.appleMusicChartId, trackChartSearchResult.chartMeta.chartId)
        Assertions.assertEquals(chartTrackLifetimeEntity.chart.appleMusicCountryId, trackChartSearchResult.chartMeta.countryCode)

        Assertions.assertEquals(chartTrackEntity.chartDate, trackChartSearchResult.metrics.date)
        Assertions.assertEquals(chartTrackEntity.prevChartDate, trackChartSearchResult.metrics.previousDate)
        Assertions.assertEquals(chartTrackEntity.currentPosition, trackChartSearchResult.metrics.position)
        Assertions.assertEquals(chartTrackEntity.prevPosition, trackChartSearchResult.metrics.previousPosition)
        Assertions.assertEquals(chartTrackEntity.trend, trackChartSearchResult.metrics.trend)

        Assertions.assertEquals(chartTrackLifetimeEntity.totalDays, trackChartSearchResult.lifetimeMetrics.totalDays)

        verify(trackLifetimeService).findChartTrackLifetimeMetricsByIds(
                mutableListOf(
                        appleMusicChartTrackLifetimeId1
                )
        )
    }

    private fun createChartTrackEntity(
            chartDate: LocalDate,
            trackId: String,
            chartId: String,
            isrc: String,
            countryCode: String,
    ): AppleMusicChartTrackEntity {
        val appleMusicChartTrackEntity = AppleMusicChartTrackEntity()

        val appleMusicChartTrackId = AppleMusicChartTrackId()
        appleMusicChartTrackId.chartDate = chartDate
        appleMusicChartTrackId.appleMusicChartId = chartId
        appleMusicChartTrackId.currentPosition = 10

        val appleMusicChartTrackKey = AppleMusicChartDateTrackKey()
        appleMusicChartTrackKey.chartDate = chartDate
        appleMusicChartTrackKey.appleMusicChartId = chartId
        appleMusicChartTrackKey.appleMusicTrackId = trackId

        appleMusicChartTrackEntity.id = appleMusicChartTrackId
        appleMusicChartTrackEntity.chartDateTrackKey = appleMusicChartTrackKey
        appleMusicChartTrackEntity.appleMusicChartId = chartId
        appleMusicChartTrackEntity.appleMusicTrackId = trackId
        appleMusicChartTrackEntity.isrc = isrc
        appleMusicChartTrackEntity.chartDate = chartDate
        appleMusicChartTrackEntity.offChartDays = 15
        appleMusicChartTrackEntity.onChartDays = 10


        appleMusicChartTrackEntity.appleMusicCountryId = countryCode
        appleMusicChartTrackEntity.prevChartDate = chartDate.minusDays(5)
        appleMusicChartTrackEntity.currentPosition = 10
        appleMusicChartTrackEntity.prevPosition = 20
        appleMusicChartTrackEntity.trend = 10
        appleMusicChartTrackEntity.isExit = false
        appleMusicChartTrackEntity.isEntry = true
        appleMusicChartTrackEntity.isReentry = false


        appleMusicChartTrackEntity.isrcPrevChartDate = chartDate.minusDays(7)
        appleMusicChartTrackEntity.isrcCurrentPosition = 15
        appleMusicChartTrackEntity.isrcPrevPosition = 12
        appleMusicChartTrackEntity.isrcTrend = 10
        appleMusicChartTrackEntity.isrcIsExit = false
        appleMusicChartTrackEntity.isrcIsEntry = true
        appleMusicChartTrackEntity.isrcIsReentry = false

        appleMusicChartTrackEntity.track = createTrackEntity(trackId, isrc, countryCode)

        appleMusicChartTrackEntity.localizedTrack = appleMusicChartTrackEntity.track.localizedTracks[0]

        appleMusicChartTrackEntity.chart = createChartEntity(chartId, countryCode)

        return appleMusicChartTrackEntity
    }

    private fun createChartEntity(
            chartId: String,
            countryCode: String,
    ): AppleMusicChartEntity? {
        val appleMusicChartEntity = AppleMusicChartEntity()
        appleMusicChartEntity.appleMusicChartId = chartId
        appleMusicChartEntity.appleMusicCountryId = countryCode
        appleMusicChartEntity.totalPositions = 100

        val marketRank = AppleMusicMarketRankEntity()
        marketRank.rank = 1
        marketRank.appleMusicCountryId = countryCode

        appleMusicChartEntity.marketRank = marketRank

        return appleMusicChartEntity
    }

    private fun createTrackEntity(
            trackId: String,
            isrc: String,
            countryCode: String,
    ): AppleMusicTrackEntity {
        val appleMusicTrackEntity = AppleMusicTrackEntity()

        val appleMusicTrackLocalizedEntity = AppleMusicTrackLocalizedEntity()
        appleMusicTrackLocalizedEntity.id = AppleMusicTrackLocalizedId(trackId, countryCode)
        appleMusicTrackLocalizedEntity.albumName = "testAlbumName"
        appleMusicTrackLocalizedEntity.artistName = "testArtistName"
        appleMusicTrackLocalizedEntity.name = "testName"
        appleMusicTrackLocalizedEntity.url = "testName"
        appleMusicTrackLocalizedEntity.appleMusicCountryId = countryCode
        appleMusicTrackLocalizedEntity.track = appleMusicTrackEntity

        val appleMusicArtistEntity = AppleMusicArtistEntity()
        appleMusicArtistEntity.appleMusicArtistId = "testArtistId1"


        appleMusicTrackEntity.appleMusicTrackId = trackId
        appleMusicTrackEntity.isrc = isrc
        appleMusicTrackEntity.isSony = true
        appleMusicTrackEntity.licensors = arrayOf("testLic1, testLic2")
        appleMusicTrackEntity.artworkUrl = "https://testArtworkUrl1"
        appleMusicTrackEntity.releaseDate = "2021-01-01"
        appleMusicTrackEntity.localizedTracks = listOf(appleMusicTrackLocalizedEntity)
        appleMusicTrackEntity.artists = listOf(appleMusicArtistEntity)

        return appleMusicTrackEntity
    }

    private fun createChartTrackLifetimeEntity(
            chartDate: LocalDate,
            trackId: String,
            chartId: String,
            isrc: String,
            countryCode: String,
    ): AppleMusicChartTrackLifetimeEntity {
        val appleMusicChartTrackLifetimeEntity = AppleMusicChartTrackLifetimeEntity()
        appleMusicChartTrackLifetimeEntity.id = "id"
        appleMusicChartTrackLifetimeEntity.totalDays = 3
        appleMusicChartTrackLifetimeEntity.minPosition = 5
        appleMusicChartTrackLifetimeEntity.maxPosition = 7
        appleMusicChartTrackLifetimeEntity.minPositionDate = chartDate
        appleMusicChartTrackLifetimeEntity.maxPositionDate = chartDate.plusDays(5)
        appleMusicChartTrackLifetimeEntity.earliestPosition = 5
        appleMusicChartTrackLifetimeEntity.earliestPositionDate = chartDate
        appleMusicChartTrackLifetimeEntity.latestPosition = 7
        appleMusicChartTrackLifetimeEntity.latestPositionDate = chartDate.plusDays(5)

        appleMusicChartTrackLifetimeEntity.track = createTrackEntity(trackId, isrc, countryCode)

        appleMusicChartTrackLifetimeEntity.chart = createChartEntity(chartId, countryCode)
        appleMusicChartTrackLifetimeEntity.isrcAndCharAndTrackIds = AppleMusicIsrcAndChartAndTrackIds(
            chartId,
            trackId, isrc
        )

        return appleMusicChartTrackLifetimeEntity
    }
}