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

import io.delphiplatform.api.v3.model.ChartTrackStateIncludes
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 AppleMusicChartTrackStateServiceTest {
    private val trackService: AppleMusicTrackService = mock()
    private val trackLifetimeService: AppleMusicChartTrackLifetimeService = mock()
    private val artistService: AppleMusicArtistService = mock()

    private val service = AppleMusicChartTrackStateService(
            trackService,
            null,
            trackLifetimeService,
            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_chartTrackStateIncludes() {
        val chartTrackStateIncludes = setOf(*ChartTrackStateIncludes.values())

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

        val enumChangedMsg = "ChartTrackStateIncludes enum fields set changed! Please update this test"
        Assertions.assertEquals(4, chartTrackStateIncludes.size, enumChangedMsg)

        Assertions.assertTrue(chartTrackStateIncludes.contains(ChartTrackStateIncludes.LICENSORS), enumChangedMsg)
        Assertions.assertTrue(chartTrackStateIncludes.contains(ChartTrackStateIncludes.METRICS), enumChangedMsg)
        Assertions.assertTrue(chartTrackStateIncludes.contains(ChartTrackStateIncludes.LIFETIME_METRICS), enumChangedMsg)
        Assertions.assertTrue(chartTrackStateIncludes.contains(ChartTrackStateIncludes.PUBLIC_META), enumChangedMsg)

        //second - test result object

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

        val appleMusicTrackLocalized1 = chartTrackEntity1.track.localizedTracks[0]

        val trackIdToTrackMetrics = mapOf(
                appleMusicTrackLocalized1.id to listOf(chartTrackEntity1)
        )

        whenever(
                trackService.findTrackIdToTrack(
                        mutableListOf(
                                appleMusicTrackLocalized1.id
                        )
                )
        ).thenReturn(
                mapOf(
                        appleMusicTrackLocalized1.id to appleMusicTrackLocalized1
                )
        )

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

        whenever(
                trackLifetimeService.findChartTrackLifetimeMetrics(
                        mutableListOf(
                                chartTrackLifetimeEntity.isrcAndCharAndTrackIds
                        )
                )
        ).thenReturn(
                mapOf(
                        appleMusicTrackLocalized1.id to chartTrackLifetimeEntity
                )
        )

        val result = service.getAppleMusicChartTrackStates(
                chartTrackStateIncludes,
                ChartTrackMetricsDimension.TRACK_ID,
                trackIdToTrackMetrics
        )

        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(date1, trackChartSearchResult.metrics.date)
        Assertions.assertEquals(chartTrackEntity1.currentPosition, trackChartSearchResult.metrics.position)

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

        verify(trackService).findTrackIdToTrack(
                mutableListOf(
                        appleMusicTrackLocalized1.id
                )
        )

        verify(trackLifetimeService).findChartTrackLifetimeMetrics(
                mutableListOf(
                        chartTrackLifetimeEntity.isrcAndCharAndTrackIds
                )
        )
    }

    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.currentPosition = 10
        appleMusicChartTrackEntity.appleMusicCountryId = countryCode
        appleMusicChartTrackEntity.isExit = false
        appleMusicChartTrackEntity.isEntry = false
        appleMusicChartTrackEntity.isReentry = false
        appleMusicChartTrackEntity.prevChartDate = chartDate.minusDays(5)
        appleMusicChartTrackEntity.prevPosition = 20
        appleMusicChartTrackEntity.offChartDays = 15
        appleMusicChartTrackEntity.onChartDays = 10
        appleMusicChartTrackEntity.trend = 10

        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 = chartId + isrc + trackId
        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.isrc = isrc

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

        appleMusicChartTrackLifetimeEntity.chart = createChartEntity(chartId, countryCode)

        appleMusicChartTrackLifetimeEntity.isrcAndCharAndTrackIds =
                AppleMusicIsrcAndChartAndTrackIds(chartId, trackId, isrc)

        return appleMusicChartTrackLifetimeEntity
    }
}