nistr

import Library._

object Desugar {

  def desugar(e: ExprExt): ExprC = e match {
    case NumExt(n)           => NumC(n)
    case PlusExt(e1, e2)     => PlusC(desugar(e1), desugar(e2))
    case MultExt(e1, e2)     => MultC(desugar(e1), desugar(e2))
    case FdExt(x, e)         => FdC(x, desugar(e))
    case AppExt(f, a)        => AppC(desugar(f), desugar(a))
    case IdExt(x)            => IdC(x)
    case ConsExt(h, t)       => ConsC(desugar(h), desugar(t))
    case NilExt()            => NilC()

    case ListExt(es) =>
      solveList(es)
    case ListMapExt(f, l) =>
      ListMapC(desugar(f), desugar(l))
    case MatrixExt(rs) =>
      solveMatrix(rs)
    case ScalarMultExt(n, m) =>

      ListMapC(
        FdC("row",
                ListMapC(
                  FdC("el", MultC(desugar(n), IdC("el"))), IdC("row"))),
        desugar(m))



      // ListMapC(
      //   FdC("row", ListMapC(FdC("x", MultC(desugar(n), IdC("x"))), IdC("row"))),
      //   desugar(m))





    // ListMapC(FdC("row",
    //   ListMapC(FdC("el", MultC(IdC("el"), desugar(n))), IdC("row"))
    // ), desugar(m))

  }

  def solveList(es: List[ExprExt]): ExprC = es match {
    case h :: t => ConsC(desugar(h), solveList(t))
    case Nil => NilC()
  }

  def solveMatrix(rs: List[RowExt]): ExprC = rs match {
    case row :: t => ConsC(solveList(row.es), solveMatrix(t))
    case Nil => NilC()
  }



}

// import Library._
//
// object Desugar {
//
//
//   def solveList(es: List[ExprExt]): ExprC = es match {
//     case h :: t => ConsC(desugar(h), solveList(t))
//     case Nil => NilC()
//   }
//
//   def solveListC(es: List[ExprC]): ExprC = es match {
//
//     case h :: t => ConsC(h, solveListC(t))
//     case Nil => NilC()
//   }
//
//   def solveRow(row: RowExt): ExprC = row match {
//     case RowExt(es) => solveList(es)
//   }
//
//   def solveMatrix(rs: List[RowExt]): ExprC = rs match {
//     case row :: t => ConsC(solveRow(row), solveMatrix(t))
//     case _ => NilC()
//
//   }
//
//   def desugar(e: ExprExt): ExprC = e match {
//     case NumExt(n)           => NumC(n)
//     case PlusExt(e1, e2)     => PlusC(desugar(e1), desugar(e2))
//     case MultExt(e1, e2)     => MultC(desugar(e1), desugar(e2))
//     case FdExt(x, e)         => FdC(x, desugar(e))
//     case AppExt(f, a)        => AppC(desugar(f), desugar(a))
//     case IdExt(x)            => IdC(x)
//     case ConsExt(h, t)       => ConsC(desugar(h), desugar(t))
//     case NilExt()            => NilC()
//
//     case ListExt(es) =>
//       solveList(es)
//     case ListMapExt(f, l) =>
//       ListMapC(desugar(f), desugar(l))
//     case MatrixExt(rs) =>
//         solveMatrix(rs)
//
//
//
//       //val rowsDesg: List[Rowrs.map(row => desugarRow(row))
//     case ScalarMultExt(n, m) =>
//     println(desugar(m))
//        ListMapC(
//          FdC("row",
//           // IdC("row") -> Cannot multiply non-number values: (NumV(3),ConsV(NumV(1),ConsV(NumV(2),ConsV(NumV(3),NilV()))))
//           ListMapC(FdC("el", MultC(desugar(n), IdC("el"))), IdC("row"))
//          ),
//          desugar(m))
//
//
//   }
//
// }
//
// // import Library._
// //
// // object Desugar {
// //
// //
// //   def desugarList(es: List[ExprExt]): ExprC = es match {
// //     case h :: t => ConsC(desugar(h), desugarList(t))
// //     case h :: Nil => desugar(h)
// //     case _ => NilC()
// //   }
// //
// //   def makeList(rows: List[ExprC]): ExprC = rows match {
// //     case rowList :: t => ConsC(rowList, makeList(t))
// //     case Nil => NilC()
// //   }
// //
// //   def solveScalarMult(n: ExprC, m: ExprC): ExprC = m match {
// //     case ConsC(h, t) =>  ConsC(ListMapC(
// //       FdC("scalar-mult", MultC(n, IdC("scalar-mult"))), h)
// //       , solveScalarMult(n, t))
// //     case NilC() => NilC()
// //   }
// //
// //   def desugar(e: ExprExt): ExprC = e match {
// //     case NumExt(n)           => NumC(n)
// //     case PlusExt(e1, e2)     => PlusC(desugar(e1), desugar(e2))
// //     case MultExt(e1, e2)     => MultC(desugar(e1), desugar(e2))
// //     case FdExt(x, e)         => FdC(x, desugar(e))
// //     case AppExt(f, a)        => AppC(desugar(f), desugar(a))
// //     case IdExt(x)            => IdC(x)
// //     case ConsExt(h, t)       => ConsC(desugar(h), desugar(t))
// //     case NilExt()            => NilC()
// //
// //     case ListExt(es) =>
// //       desugarList(es)
// //
// //     case ListMapExt(f, l) =>
// //       ListMapC(desugar(f), desugar(l))
// //
// //     case MatrixExt(rs) =>
// //       val rows: List[ExprC] = rs.map(row => desugarList(row.es))
// //       makeList(rows)
// //
// //     case ScalarMultExt(n, m) => // solveScalarMult(desugar(n), desugar(m))
// //       ListMapC(FdC("x", ListMapC(FdC("y", MultC(desugar(n), IdC("y"))), IdC("x"))), desugar(m))
// //       // ListMapC(FdC("x", ListMapC(FdC("mul", MultC(desugar(n), IdC("mul"))))), desugar(m))
// //
// //     // desugar(m) match {
// //     // case ConsC(h, t) => ConsC(ListMapC(FdC("x", MultC(desugar(n), IdC("x"))), h), desugar(ScalarMultExt(n, t)))
// //     // case NilC() => NilC()
// //     // }
// //
// //
// //
// //   }
// //
// // }
// // //Expected ConsV(ConsV(NumV(3),ConsV(NumV(6),ConsV(NumV(9),NilV()))),ConsV(ConsV(NumV(12),ConsV(NumV(15),ConsV(NumV(18),NilV()))),NilV())),
// // // but got ConsV(ConsV(NumV(3),ConsV(NumV(2),ConsV(NumV(3),NilV()))),ConsV(ConsV(NumV(12),ConsV(NumV(5),ConsV(NumV(6),NilV()))),NilV()))