package io.delphiplatform.api.v3.rdb.service.spotify

import io.delphiplatform.api.v3.model.ChartTrackStateIncludes
import io.delphiplatform.api.v3.model.spotify.ChartTrackMetricsDimension
import io.delphiplatform.api.v3.model.spotify.SpotifyChartBreakdown
import io.delphiplatform.api.v3.model.spotify.SpotifyChartType
import io.delphiplatform.api.v3.rdb.entity.spotify.*
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 SpotifyChartTrackStateServiceTest {
    private val trackLifetimeService: SpotifyChartTrackLifetimeService = mock()
    private val trackService: SpotifyTrackService = mock()

    private val service = SpotifyChartTrackStateService(
            trackLifetimeService,
            null,
            trackService,
    )

    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_getSpotifyChartTrackStates_chartTrackStateIncludes() {
        val chartTrackStateIncludes = setOf(*ChartTrackStateIncludes.values())

        //first - check if ChartTrackStateIncludes enum has changed. If so - would need to update this test
        // (getSpotifyChartTrackStates() 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 spotifyTrackId1 = chartTrackEntity1.track.id

        val trackIdToTrackMetrics = mapOf(
                spotifyTrackId1 to listOf(chartTrackEntity1)
        )

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

        whenever(
                trackLifetimeService.findTrackLifetimeMetrics(
                        setOf(spotifyTrackId1.spotifyTrackId),
                        chartId1
                )
        ).thenReturn(
                mapOf(
                        spotifyTrackId1 to chartTrackLifetimeEntity
                )
        )

        whenever(
                trackService.findTrackIdToTrack(
                        setOf(spotifyTrackId1)
                )
        ).thenReturn(
                mapOf(
                        spotifyTrackId1 to chartTrackEntity1.track
                )
        )

        val result = service.getSpotifyChartTrackStates(
                chartId1,
                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.id.spotifyTrackId, trackChartSearchResult.publicMeta.trackId)
        Assertions.assertEquals(chartTrackLifetimeEntity.track.isrc, trackChartSearchResult.publicMeta.isrc)
        Assertions.assertEquals(chartTrackLifetimeEntity.track.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(trackLifetimeService).findTrackLifetimeMetrics(
                setOf(spotifyTrackId1.spotifyTrackId),
                chartId1
        )

        verify(trackService).findTrackIdToTrack(
                setOf(spotifyTrackId1)
        )
    }

    private fun createChartTrackEntity(
            chartDate: LocalDate,
            trackId: String,
            chartId: String,
            isrc: String,
            countryCode: String,
    ): SpotifyChartTrackEntity {
        val spotifyChartTrackEntity = SpotifyChartTrackEntity()
        val spotifyChartTrackId = SpotifyChartTrackId()
        spotifyChartTrackId.chartDate = chartDate
        spotifyChartTrackId.spotifyChartId = chartId
        spotifyChartTrackId.currentPosition = 10

        val spotifyChartDateTrackKey = SpotifyChartDateTrackKey()
        spotifyChartDateTrackKey.chartDate = chartDate
        spotifyChartDateTrackKey.spotifyChartId = chartId
        spotifyChartDateTrackKey.spotifyTrackId = trackId

        spotifyChartTrackEntity.id = spotifyChartTrackId
        spotifyChartTrackEntity.chartDateTrackKey = spotifyChartDateTrackKey
        spotifyChartTrackEntity.spotifyChartId = chartId
        spotifyChartTrackEntity.spotifyTrackId = trackId
        spotifyChartTrackEntity.chartDate = chartDate
        spotifyChartTrackEntity.currentPosition = 10
        spotifyChartTrackEntity.isExit = false
        spotifyChartTrackEntity.isEntry = false
        spotifyChartTrackEntity.isReentry = false
        spotifyChartTrackEntity.prevPosition = 20
        spotifyChartTrackEntity.isrc = isrc
        spotifyChartTrackEntity.isrcPrevPosition = 15

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

        spotifyChartTrackEntity.chart = createChartEntity(chartId, countryCode, SpotifyChartType.REGIONAL)

        return spotifyChartTrackEntity
    }

    private fun createChartEntity(
            chartId: String,
            countryCode: String,
            spotifyChartType: SpotifyChartType
    ): SpotifyChartEntity? {
        val spotifyChartEntity = SpotifyChartEntity()
        spotifyChartEntity.spotifyChartId = chartId
        spotifyChartEntity.spotifyCountryId = countryCode
        spotifyChartEntity.type = spotifyChartType
        spotifyChartEntity.breakdown = SpotifyChartBreakdown.DAILY

        val marketRank = SpotifyMarketRankEntity()
        marketRank.rank = 1
        marketRank.spotifyCountryId = countryCode

        spotifyChartEntity.marketRank = marketRank

        return spotifyChartEntity
    }

    private fun createTrackEntity(
            trackId: String,
            isrc: String,
            countryCode: String,
    ): SpotifyTrackEntity {
        val spotifyTrackEntity = SpotifyTrackEntity();

        val spotifyTrackId = SpotifyTrackId()
        spotifyTrackId.spotifyTrackId = trackId
        spotifyTrackId.spotifyCountryId = countryCode

        spotifyTrackEntity.id = spotifyTrackId

        spotifyTrackEntity.isrc = isrc
        spotifyTrackEntity.isSony = true
        spotifyTrackEntity.licensors = arrayOf("testLic1, testLic2")
        spotifyTrackEntity.uri = "https://testUri1"
        spotifyTrackEntity.releaseDate = "2021-01-01"
        spotifyTrackEntity.imageUrl = "https://testImageUrl1"
        spotifyTrackEntity.name = "testName"
        spotifyTrackEntity.artists = emptyList()

        return spotifyTrackEntity
    }

    private fun createChartTrackLifetimeEntity(
            id: String,
            chartDate: LocalDate,
            trackId: String,
            chartId: String,
            isrc: String,
            countryCode: String,
    ): SpotifyChartTrackLifetimeEntity {
        val spotifyChartTrackLifetimeEntity = SpotifyChartTrackLifetimeEntity()
        spotifyChartTrackLifetimeEntity.id = id
        spotifyChartTrackLifetimeEntity.spotifyChartId = chartId
        spotifyChartTrackLifetimeEntity.spotifyTrackId = trackId
        spotifyChartTrackLifetimeEntity.spotifyCountryId = countryCode
        spotifyChartTrackLifetimeEntity.totalDays = 3
        spotifyChartTrackLifetimeEntity.minPosition = 5
        spotifyChartTrackLifetimeEntity.maxPosition = 7
        spotifyChartTrackLifetimeEntity.minPositionDate = chartDate
        spotifyChartTrackLifetimeEntity.maxPositionDate = chartDate.plusDays(5)
        spotifyChartTrackLifetimeEntity.earliestPosition = 5
        spotifyChartTrackLifetimeEntity.earliestPositionDate = chartDate
        spotifyChartTrackLifetimeEntity.latestPosition = 7
        spotifyChartTrackLifetimeEntity.latestPositionDate = chartDate.plusDays(5)
        spotifyChartTrackLifetimeEntity.isrc = isrc
        spotifyChartTrackLifetimeEntity.isrcTotalDays = 3
        spotifyChartTrackLifetimeEntity.isrcMinPosition = 5
        spotifyChartTrackLifetimeEntity.isrcMaxPosition = 7
        spotifyChartTrackLifetimeEntity.isrcMinPositionDate = chartDate
        spotifyChartTrackLifetimeEntity.isrcMaxPositionDate = chartDate.plusDays(5)
        spotifyChartTrackLifetimeEntity.isrcEarliestPosition = 5
        spotifyChartTrackLifetimeEntity.isrcEarliestPositionDate = chartDate.plusDays(5)
        spotifyChartTrackLifetimeEntity.isrcLatestPosition = 7
        spotifyChartTrackLifetimeEntity.isrcLatestPositionDate = chartDate.plusDays(5)

        spotifyChartTrackLifetimeEntity.isrcAndChartAndTrackIds = IsrcAndChartAndTrackIds(chartId, trackId, isrc)

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

        return spotifyChartTrackLifetimeEntity
    }
}