//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
/** @author  John Miller
 *  @version 1.6
 *  @date    Sat Jun 13 01:27:00 EST 2017
 *  @see     LICENSE (MIT style license file).
 *
 *  @title   Test: Economics Domain using ARIMA family
 */

package scalation.analytics
package forecaster

import scalation.linalgebra.{MatrixD, VectoD, VectorD, VectorI}
import scalation.plot.Plot
import scalation.stat.Statistic
import scalation.util.banner

import ActivationFun._
import ImputeMean.{impute, setMissVal}

//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
/** The `ExampleEcon2_SARIMA` object tests various prediction and forecasting techniques
 *  on daily economic/finance time-series data.
 *  > runMain scalation.analytics.forecaster.ExampleEcon2_SARIMA
 */
object ExampleEcon2_SARIMA extends App
{
    val tech    = Set ("ARIMA")//, "MA", "ARMA", "ARIMA")
    val MISSING = -999999                                   // missing value

    val xyr = MatrixD (BASE_DIR + "ENERGY20200603.csv", 1)
//  val xyr = MatrixD (BASE_DIR + "ENERGY_DATA.csv", 1)
//  val xyr = MatrixD (BASE_DIR + "MERGED_DATA_7_25.csv", 1)
//  val xyr = MatrixD (BASE_DIR + "RESEARCH_DATA.csv", 1)
    println (s"xyr.dim1 = ${xyr.dim1}, xy.dim2 = ${xyr.dim2}")

    val xy = xyr.sliceCol (2, xyr.dim2)

//    setMissVal (MISSING)
//    var xy = impute (xyr) // * 100.0

    for (j <- xy.range2) {
        banner (s"column $j")
        val y  = xy.col (j)
        println (s"ymean = ${y.mean}, ymin = ${y.min()}, ymax = ${y.max()}")

        for (i <- y.range if y(i) == MISSING) println (s"i = $i, y(i) = ${y(i)}}")
        for (i <- y.dim - 5 until y.dim) println (s"i = $i, y(i) = ${y(i)}}")
    } // for

//  xy = xy.slice (0, 200)                                  // comment out for all rows
    val _1 = VectorD.one (xy.dim1)                          // column of all ones
    println (s"xy.dim1 = ${xy.dim1}, xy.dim2 = ${xy.dim2}")

// forecast column 0 using columns 1-7
    val RESPONSE = 0                                        // for ENERGY_DATA.csv
    val FEATURE1 = 1                                        // for ENERGY_DATA.csv
    val FEATURE2 = 7                                        // for ENERGY_DATA.csv
    val y = xy.col (RESPONSE)
    val x = xy.sliceCol (FEATURE1, FEATURE2)

    val t = VectorD.range (0, y.dim)
    println (s"x.dim1 = ${x.dim1}, x.dim2 = ${x.dim2}")

    val rescaled = false                                    // whether to rescale data
    val h        = 5                                        // forecasting horizon

   //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    /** Test the model.
     *  @param modName  the name of the model to test
     *  @param mod      the model to test
     *  @param kt       the retraining frequency
     *  @param h        the forecasting horizon
     */
    def test (modName: String, mod: SARIMA, kt: Int = h, h: Int = h)
    {
        banner (s"Test $modName")
        mod.train ().eval ()
        val yf = mod.forecastAll (h = h)                    // forecast for all times and horizons

        for (k <- 1 to h) { // FIX
            banner (s"$modName: forecasting horizon h = $k")
            val yf_k = yf(k)
            if (y.dim != yf_k.dim) flaw ("test", s"y.dim = ${y.dim} != yf_k.dim = ${yf_k.dim}")
            mod.eval_ (y, yf_k)
            println (mod.fitMap)
            new Plot (null, y, yf_k, s"$modName in sample horizon $k: y and yf", true)
            mod.init (y)
            val stats = SimpleRollingValidation.crossValidate2 (mod, kt, k)      // was 2S
//          val stats = RollingValidation.crossValidate2 (mod, kt, k)
            Fit.showQofStatTable (stats)
        } // for
    } // test

    if (tech contains "AR") {
        val ar = new SARIMA (y)
        for (p <- 1 to 6) {
            ar.init (y)
            ar.setPQ (VectorI (p, 0))
            test (s"AR($p)", ar)
        } // for
    } // if

    if (tech contains "MA") {
        val ma = new SARIMA (y)
        for (q <- 1 to 6) {
            ma.init (y)
            ma.setPQ (VectorI (0, q))
            test (s"MA($q)", ma)
        } // for
    } // if

    val q = 1
    if (tech contains "ARMA") {
        val arma = new SARIMA (y)
        for (p <- 1 to 2) {
            arma.init (y)
            arma.setPQ (VectorI (p, q))
            test(s"ARMA($p, $q)", arma)
        } // for
    } // if

    val d = 1
    if (tech contains "ARIMA") {
        val arima = new SARIMA (y, d)
        for (p <- 1 to 4; q <- 1 to 2) {
            arima.init (y)
            arima.setPQ (VectorI (p, q))
            test(s"ARIMA($p, $d, $q)", arima)
        } // for
    } // if

} // ExampleEcon2_SARIMA object