/*
 * Copyright (c) 2017 Yuki Ono
 * Licensed under the MIT License.
 */

package func_basic

import scala.annotation.tailrec

object Main extends App {
    def proceduralSum(ns: List[Int]): Int = {
        var sum = 0

        var i = 0
        while (i < ns.length) {
            sum += ns(i)
            i += 1
        }

        return sum
    }

    def recSum(ns: List[Int]): Int = ns match {
        case Nil => 0
        case n :: rest => n + recSum(rest)
    }

    def tailRecSum(ns: List[Int]): Int = {
        @tailrec
        def loop(l: List[Int], acc: Int): Int = l match {
            case Nil => acc
            case n :: rest => loop(rest, n + acc)
        }

        loop(ns, 0)
    }

    def foldLeftSum(ns: List[Int]): Int = {
        ns.foldLeft(0)((b, a) => b + a)
        //ns.foldLeft(0)(_ + _)
    }

    def foldRightSum(ns: List[Int]): Int = {
        ns.foldRight(0)((a, b) => a + b)
        // ns.foldRight(0)(_ + _)
    }

    def reduceLeftSum(ns: List[Int]): Int = {
        ns.reduceLeft((b, a) => b + a)
        //ns.reduceLeft(_ + _)
    }

    def reduceRightSum(ns: List[Int]): Int = {
        ns.reduceRight((a, b) => a + b)
        //ns.reduceRight(_ + _)
    }

    def sumSum(ns: List[Int]): Int = {
        ns.sum
    }

    val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    //val numbers = (1 to 10).toList

    println("*** Sum ***")
    println(proceduralSum(numbers))
    println(recSum(numbers))
    println(tailRecSum(numbers))
    println(foldLeftSum(numbers))
    println(foldRightSum(numbers))
    println(reduceLeftSum(numbers))
    println(reduceRightSum(numbers))
    println(sumSum(numbers))



    def proceduralFactorial(num: Int): Long = {
        require(num >= 0)

        var fn = 1L

        var i = 1
        while (i <= num) {
            fn *= i
            i += 1
        }

        return fn
    }

    def recFactorial(num: Int): Long = {
        require(num >= 0)

        num match {
            case 0 => 1
            case n => n * recFactorial(n - 1)
        }
    }

    def tailRecFactorial(num: Int): Long = {
        require(num >= 0)

        @tailrec
        def loop(n: Long, acc: Long): Long = n match {
            case 0 => acc
            case _ => loop(n - 1, n * acc)
        }

        loop(num, 1)
    }

    def foldLeftFactorial(num: Int): Long = {
        require(num >= 0)

        (1 to num).foldLeft(1L)((b, a) => b * a)
        //(1 to num).foldLeft(1L)(_ * _)
    }

    def foldRightFactorial(num: Int): Long = {
        require(num >= 0)

        (1 to num).foldRight(1L)((a, b) => a * b)
    }

    println()
    println("*** Factorial ***");
    println(proceduralFactorial(10))
    println(recFactorial(10))
    println(tailRecFactorial(10))
    println(foldLeftFactorial(10))
    println(foldRightFactorial(10))



    def proceduralFib(num: Int): Int = {
        if (num < 2)
            return num

        var fib1 = 0
        var fib2 = 1
        var temp = 0

        var i = 2
        while (i <= num) {
            temp = fib1
            fib1 = fib2
            fib2 = temp + fib2

            i += 1
        }

        return fib2
    }

    def recFib(num: Int): Int = num match {
        case n if n < 2 => n
        case n => recFib(n - 1) + recFib(n - 2)
    }

    def tailRecFib(num: Int): Int = {
        @tailrec
        def loop(n: Int, a: Int, b: Int): Int = n match {
            case 0 => a
            case n => loop(n - 1, b, (a + b))
        }

        loop(num, 0, 1)
    }

    def memoFib(num: Int): Int = {
        val memo = collection.mutable.Map[Int, Int]()

        def fib(n: Int) = n match {
            case n if n < 2 => n
            case _ => memoFib(n - 1) + memoFib(n - 2)
        }

        memo.get(num) match {
            case Some(res) => res
            case None => {
                val res = fib(num)
                memo(num) = res
                res
            }
        }
    }

    println()
    println("*** Fibonacci ***")
    println(proceduralFib(10))
    println(recFib(10))
    println(tailRecFib(10))
    println(memoFib(10))



    def proceduralX2(ns: List[Int]): List[Int] = {
        val buf = scala.collection.mutable.ListBuffer.empty[Int]

        var i = 0;
        while (i < ns.length) {
            buf += ns(i) * 2
            i += 1
        }

        return buf.toList
    }

    def recX2(ns: List[Int]): List[Int] = ns match {
        case Nil => Nil
        case n :: rest => (n * 2) :: recX2(rest)
    }

    def tailRecX2(ns: List[Int]): List[Int] = {
        @tailrec
        def loop(l: List[Int], acc: List[Int]): List[Int] = l match {
            case Nil => acc
            case n :: rest => loop(rest, (n * 2) :: acc)
        }

        loop(ns, Nil).reverse
    }

    def foldLeftX2(ns: List[Int]): List[Int] = {
        ns.foldLeft(List[Int]())((b, a) => (a * 2) :: b).reverse
    }

    def foldRightX2(ns: List[Int]): List[Int] = {
        ns.foldRight(List[Int]())((a, b) => (a * 2) :: b)
    }

    def mapX2(ns: List[Int]): List[Int] = {
        val x2 = (n: Int) => n * 2
        ns.map(x2)

        //ns.map(n => n * 2)
        //ns.map(_ * 2)
    }

    println()
    println("*** X2 ***")
    println(proceduralX2(numbers))
    println(recX2(numbers))
    println(tailRecX2(numbers))
    println(foldLeftX2(numbers))
    println(foldRightX2(numbers))
    println(mapX2(numbers))



    def proceduralEven(ns: List[Int]): List[Int] = {
        val buf = scala.collection.mutable.ListBuffer.empty[Int]

        var i = 0;
        while (i < ns.length) {
            if (ns(i) % 2 == 0)
                buf += ns(i)

            i += 1
        }

        return buf.toList
    }

    def recEven(ns: List[Int]): List[Int] = ns match {
        case Nil => Nil
        case n :: rest => if (n % 2 == 0) n :: recEven(rest) else recEven(rest)
    }

    def tailRecEven(ns: List[Int]): List[Int] = {
        def loop(l: List[Int], acc: List[Int]): List[Int] = l match {
            case Nil => acc
            case n :: rest => loop(rest, if (n % 2 == 0) n :: acc else acc)
        }

        loop(ns, Nil).reverse
    }

    def filterEven(ns: List[Int]): List[Int] = {
        val isEven = (n: Int) => n % 2 == 0
        ns.filter(isEven)

        //ns.filter(n => n % 2 == 0)
        //ns.filter(_ % 2 == 0)
    }

    println()
    println("*** Even ***")
    println(proceduralEven(numbers))
    println(recEven(numbers))
    println(tailRecEven(numbers))
    println(filterEven(numbers))
}