package publisher.dashboard

import browser.AdaptiveBrowser
import common.integration.dump.DBQuery
import common.integration.dump.dumps.{C3MergedTables, PublisherDashboardDump}
import infrastructure.FakeInfrastructureWithNodeJs
import org.apache.commons.lang.time.DateUtils
import org.joda.time.DateTime
import org.openqa.selenium.JavascriptExecutor
import page.publisher.dashboard.DataRange.DataRange
import page.publisher.dashboard.{DataRange, ItemsPerPage, PublisherDashboard}
import play.api.test.PlaySpecification

/**
  * Created by olharuban on 7/22/16.
  */

class PublisherDashboardSpec extends PlaySpecification with FakeInfrastructureWithNodeJs
  with PublisherDashboardDump with DBQuery {

  import PublisherDashboard._

  lazy val publisherDashboard = PublisherDashboard(browser)
  lazy val asserts: Asserts = new Asserts()

  s"\nPublisher dashboard" should {

    import DBHelper._

    sequential

    val now: DateTime = DateTime.now().minusDays(1)

    "display data for first media group" in {

      val mediaGroupName = "101 holidays Ltd"
      val mediaGroupId = 137

      "have page loaded successfully" in {
        maximizeScreen(browser)
        publisherDashboard.goWithCookie()
        publisherDashboard.isCurrentPage
      }

      "display selected media group name" in {
        publisherDashboard.selectMediaGroup(mediaGroupName)
        publisherDashboard.currentMediaGroupName.getText must be equalTo mediaGroupName.toUpperCase
      }

      Seq((DataRange.Yesterday, now, now),
        (DataRange.WTD, now.withDayOfWeek(1), now),
        (DataRange.MTD, now.withDayOfMonth(1), now),
        (DataRange.YTD, now.withDayOfYear(1), now),
        (DataRange.CUSTOM, now.minusDays(49), now.minusDays(49)
          )
      ).map {
        case (range: DataRange, startDate: DateTime, endDate: DateTime) =>

          s"have the same data with DB for $range data range" in {

            "data picker and data range values" in {
              if (range == DataRange.CUSTOM)
                publisherDashboard.setDatesWithJson(mediaGroupId.toString, startDate, endDate)
              else
                publisherDashboard.selectDataRange(range)

              if (range == DataRange.WTD  &&
                now.getDayOfWeek == 1
              ) {
                asserts.assertDataRange(DataRange.Yesterday)
              } else {
                asserts.assertDataRange(range)
              }
              asserts.assertCurrentDataPicker(startDate, endDate)
            }

            "table with same rows of impressions and revenues" in {
              publisherDashboard.getTableValues.sorted should be equalTo
                getImpressionsAndRevenues(mediaGroupName, Some(startDate), Some(endDate)).sorted
            }

            "unique users and unique keywords" in {
              asserts.assertUniqueUsersAndUniqueSearchesEqualsWithDB(mediaGroupId)
            }

            "total impressions server, total revenue and total keywords" in {
              asserts.assertTotalValues(mediaGroupName, startDate, endDate)
            }

          }

      }

      "have pagination and table expander" in {
        publisherDashboard.selectDataRange(DataRange.YTD)
        publisherDashboard.expandTable(ItemsPerPage._10)
        publisherDashboard.tableParamsRows.size() aka "columns count" mustEqual 10
        publisherDashboard.selectNextPage
        publisherDashboard.tableParamsRows.size() aka "columns count" mustEqual 10
        publisherDashboard.selectPreviousPage
        publisherDashboard.selectPage(2)
        publisherDashboard.expandTable(ItemsPerPage._25)
        publisherDashboard.tableParamsRows.size() aka "columns count" mustEqual 20
      }

      "display table for specific media group property" in {
        browser.executeScript("scroll(0, -250);")
        publisherDashboard.selectProperty("101HONEYMOONS.CO.UK")
        publisherDashboard.getTableValues.sorted should be equalTo
          getImpressionsAndRevenuesForProperty(11037, None, None).sorted

        publisherDashboard.selectProperty("101HOLIDAYS.CO.UK")
        publisherDashboard.getTableValues.sorted should be equalTo
          getImpressionsAndRevenuesForProperty(11036, None, None).sorted

      }

    }

    "display data when change media group" in {

      val mediaGroupName = "33 Across Inc."
      val mediaGroupId = 227
      val startDate = now.withDayOfYear(1)
      val endDate = now

      "display selected media group name" in {
        publisherDashboard.selectMediaGroup(mediaGroupName)
        publisherDashboard.currentMediaGroupName.getText must be equalTo mediaGroupName.toUpperCase
      }

      "table with same rows of impressions and revenues" in {
        publisherDashboard.getTableValues.sorted should be equalTo
          getImpressionsAndRevenues(mediaGroupName, Some(startDate), Some(endDate)).sorted
      }

      "unique users and unique keywords" in {
        asserts.assertUniqueUsersAndUniqueSearchesEqualsWithDB(mediaGroupId)
      }

      "total impressions server, total revenue and total keywords" in {
        asserts.assertTotalValues(mediaGroupName, startDate, endDate)
      }

    }

  }

  class Asserts() {

    def assertUniqueUsersAndUniqueSearchesEqualsWithDB(mediaGroupId: Int) = {
      val uniqueUsersAndUniqueSearches = DBHelper.getUniqueUsersAndUniqueSearches(mediaGroupId)
      publisherDashboard.getUniqueUsers aka "Unique users" should be equalTo uniqueUsersAndUniqueSearches._1
      publisherDashboard.getUniqueKeywords aka "Unique keywords" should be equalTo uniqueUsersAndUniqueSearches._2
    }

    def assertTotalValues(mediaGroupName: String, startDate: DateTime, endDate: DateTime) = {
      val totals = DBHelper.getTotalValues(mediaGroupName, Some(startDate), Some(endDate))
      publisherDashboard.getTotalImpressionServed aka "Total Impression" should be equalTo totals._1
      publisherDashboard.totalRevenue.getText aka "Total Revenue" must be equalTo totals._2
      publisherDashboard.getTotalKeywords aka "Total Keywords" must be equalTo totals._3

      publisherDashboard.getTableTotalImpressions aka "Total Impression from table" should be equalTo totals._1
      publisherDashboard.tableTotalRevenue.getText aka "Total Revenue from table" must be equalTo totals._2
    }

    def assertCurrentDataPicker(startDate: DateTime, endDate: DateTime) = {
      val startDateFormatted = datapickerStartDateFormat.print(startDate)
      val endDateFormatted = datapickerEndDateFormat.print(endDate)
      publisherDashboard.getCurrentDatapickerDate must beEqualTo(startDateFormatted + "-" + endDateFormatted).ignoreCase
    }

    def assertDataRange(range: DataRange) = {
      publisherDashboard.getCurrentDataRange must beEqualTo(range.toString)
    }

  }

  object DBHelper {

    def getImpressionsAndRevenues(publisherName: String,
                                  startDate: Option[DateTime] = None,
                                  endDate: Option[DateTime] = None): List[(String, String, String)] = {

      val responseString =
        s"""SELECT pub_dash_cube.day_start_utc::timestamp::date as day,
        sum(impressions) as "impressions",
        concat(sel_currency.symbol, cast(sum(revenues_property_currency) as decimal(10,2))) as "revenues"
        FROM pub_dash_cube
        JOIN media_group
        ON media_group.id = pub_dash_cube.mediagroup_id
        JOIN sel_currency
        ON sel_currency.id = media_group.currency
        WHERE media_group.name = '$publisherName' """ +
          (for {
            startDateVal <- startDate
            endDateVal <- endDate
          } yield {
            s" AND cast(pub_dash_cube.day_start_utc as date) between '${dbDateFormat.print(startDate.get)}' " + s"and '${dbDateFormat.print(endDate.get)}'"
          }).getOrElse("") +
          """ GROUP BY day, sel_currency.symbol
        ORDER BY day asc """
      val rs = executeSQL(responseString)

      Iterator.continually((rs.next(), rs)).takeWhile(_._1)
        .map { case (present, col) => (col.getString(1), col.getString(2), col.getString(3)) }.toList
    }

    def getUniqueUsersAndUniqueSearches(publisherId: Int): (Int, Int) = {
      getResponse(
        s"""
         SELECT unique_users, unique_searches
         FROM pub_dash_cube_30days
         WHERE mediagroup_id = '$publisherId'""") match {
        case col => (col.getInt(1), col.getInt(2))
      }
    }

    def getTotalValues(publisherName: String,
                       startDate: Option[DateTime] = None,
                       endDate: Option[DateTime] = None): (Int, String, Int) = {
      val responseString =
        s"""
          SELECT  sum(impressions) as "impressions",
          concat(sel_currency.symbol, cast(sum(revenues_property_currency) as decimal(10,2))) as "revenues",
          sum(searches) as "total_keywords"
          FROM pub_dash_cube
          JOIN media_group
          ON media_group.id = pub_dash_cube.mediagroup_id
          JOIN sel_currency
          ON sel_currency.id = media_group.currency
          WHERE media_group.name = '$publisherName' """ +
          (for {
            startDateVal <- startDate
            endDateVal <- endDate
          } yield {
            s" AND cast(pub_dash_cube.day_start_utc as date) between '${dbDateFormat.print(startDate.get)}' and '${dbDateFormat.print(endDate.get)}'"
          }).getOrElse("") +
          " GROUP BY sel_currency.symbol "
      getResponse(responseString) match {
        case col => (col.getInt(1), col.getString(2), col.getInt(3))
      }

    }

    def getImpressionsAndRevenuesForProperty(propertyId: Int,
                                             startDate: Option[DateTime] = None,
                                             endDate: Option[DateTime] = None): List[(String, String, String)] = {

      val responseString =
        s"""SELECT pub_dash_cube.day_start_utc::timestamp::date as day,
        sum(impressions) as "impressions",
        concat(sel_currency.symbol, cast(sum(revenues_property_currency) as decimal(10,2))) as "revenues"
        FROM pub_dash_cube
        JOIN media_group
        ON media_group.id = pub_dash_cube.mediagroup_id
        JOIN sel_currency
        ON sel_currency.id = media_group.currency
        WHERE pub_dash_cube.property_id = '$propertyId' """ +
          (for {
            startDateVal <- startDate
            endDateVal <- endDate
          } yield {
            s" AND cast(pub_dash_cube.day_start_utc as date) between '${dbDateFormat.print(startDate.get)}' " + s"and '${dbDateFormat.print(endDate.get)}'"
          }).getOrElse("") +
          """ GROUP BY day, sel_currency.symbol
        ORDER BY day asc """
      val rs = executeSQL(responseString)

      Iterator.continually((rs.next(), rs)).takeWhile(_._1)
        .map { case (present, col) => (col.getString(1), col.getString(2), col.getString(3)) }.toList
    }
  }


}