import scala.math._

def filterMapDoble(inputList: List[Int], fnFiltro: Int => Boolean, f1: Int => Int, f2: Int => Int): (List[Int], List[Int]) = {
// La idea de la función filtrar es tomar el primer elemento de la lista y situarlo
// en la lista de salida apropiada, dependiendo si cumple o no con la función fnFiltro.
// Luego la función se llama recursivamente con el "tail" de la lista de entrada.

def filtrar(l: List[Int], f: Int => Boolean): (List[Int], List[Int]) = {
    if (!l.isEmpty) {
    val matchValue = if (f(l.head)) List(l.head) else List[Int]()
    val notMatchValue = if (f(l.head)) List[Int]() else List(l.head)

    (matchValue ::: filtrar(l.tail, f)._1, notMatchValue ::: filtrar(l.tail, f)._2)
    } else (List[Int](), List[Int]())
}

// La función applyFunctionToList evalúa la función g() para el primer elemento de
// la lista, y lo concatena con la llamada recursiva a applyFunctionToList en donde
// la lista de referencia es el "tail" de la lista del nivel anterior
def applyFunctionToList(l: List[Int], g: Int => Int): List[Int] = {
    if (!l.isEmpty) {
    (List(g(l.head)) ::: applyFunctionToList(l.tail, g))
    } else List[Int]()
}

println(s"Lista de entrada: $inputList")
// La función filterMapDoble inicia con la separación de la lista en dos,
// de acuerdo a la fnFiltro.
val filteredLists = filtrar(inputList, fnFiltro)

// Y finalmente se devuelve una tupla de listas en las cuales a la primera se le aplica
// la función f1 y a la otra f2.
val outputList1 = applyFunctionToList(filteredLists._1, f1)
val outputList2 = applyFunctionToList(filteredLists._2, f2)
println(s"Listas de salida: $outputList1, $outputList2")
(outputList1, outputList2)
}
println("Parte 1: Programación funcional y recursiva en Scala")

// Probando el ejemplo del enunciado, se filtran las listas en el caso
// de si el elemento es par o no; si es par, dividirlo entre 2; y si es impar, multiplicarlo por 2
println("\nPrueba #1 - Implementando el ejemplo del enunciado")
val testList = List(1, 3, 5, 7, 4, 6, 8)
filterMapDoble(testList, x => x % 2 == 0, x => x / 2, x => x * 2)

// Probando las mismas funciones para un objeto de entrada Nil,
// se puede observar que la salida es List(), List()
println("\nPrueba #2 - Probando las funciones del enunciado para una lista de entrada Nil")
val testList2 = Nil
filterMapDoble(testList2, x => x % 2 == 0, x => x / 2, x => x * 2)

// Ahora pruebas adicionales con otras funciones
def producto (f: (Int) => Int) (a: Int, b: Int): Int = {
    if (a > b) 1
    else f(a) * producto(f)(a+1, b)
}
def factorial (n: Int): Int = producto(x => x)(1, n)

println("\nPrueba #3 - Calcula factorial solo para los enteros positivos, negativos se convierten en cero")
val testList3 = List(-3, -2, -1, 0, 1, 2, 3)
filterMapDoble(testList3, x => x >= 0, factorial, x => 0)

val log2 = (x: Double) => log10(x)/log10(2.0)
val isPowerOfTwo = (x: Int) => log2(x) % 2 == 0 || log2(x) % 2 == 1

println("\nPrueba #4 - Filtra los números que son potencia de 2, los que no lo son, se convierten a la potencia de 2 más cercana")
val testList4 = List(2, 6, 7, 42, 33, 64, 1024, 743)
filterMapDoble(testList4, isPowerOfTwo, x => x, x => pow(2, round(log2(x)).toDouble).toInt)