// Scala Lecture 3

//=================

// last week:

// higher-order functions

// maps

// - recursion

// - Sudoku

// - string interpolations

// - Pattern-Matching

// A Recursive Web Crawler / Email Harvester

//===========================================

//

// the idea is to look for links using the

// regular expression "https?://[^"]*" and for

// email addresses using another regex.

import io.Source

import scala.util._

// gets the first 10K of a web-page

def get_page(url: String) : String = {

  Try(Source.fromURL(url)("ISO-8859-1").take(10000).mkString).

    getOrElse { println(s"  Problem with: $url"); ""}

}

// regex for URLs and emails

val http_pattern = """"https?://[^"]*"""".r

val email_pattern = """([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})""".r

//test case:

//email_pattern.findAllIn

//  ("foo bla christian@kcl.ac.uk 1234567").toList

// drops the first and last character from a string

def unquote(s: String) = s.drop(1).dropRight(1)

def get_all_URLs(page: String): Set[String] = 

  http_pattern.findAllIn(page).map(unquote).toSet

// naive version of crawl - searches until a given depth,

// visits pages potentially more than once

def crawl(url: String, n: Int) : Unit = {

  if (n == 0) ()

  else {

    println(s"  Visiting: $n $url")

    for (u <- get_all_URLs(get_page(url))) crawl(u, n - 1)

  }

}

// some starting URLs for the crawler

val startURL = """https://nms.kcl.ac.uk/christian.urban/"""

crawl(startURL, 2)

// a primitive email harvester

def emails(url: String, n: Int) : Set[String] = {

  if (n == 0) Set()

  else {

    println(s"  Visiting: $n $url")

    val page = get_page(url)

    val new_emails = email_pattern.findAllIn(page).toSet

    new_emails ++ (for (u <- get_all_URLs(page)) yield emails(u, n - 1)).flatten

  }

}

emails(startURL, 2)

// Sudoku 

//========

// THE POINT OF THIS CODE IS NOT TO BE SUPER

// EFFICIENT AND FAST, just explaining exhaustive

// depth-first search

val game0 = """.14.6.3..

              |62...4..9

              |.8..5.6..

              |.6.2....3

              |.7..1..5.

              |5....9.6.

              |..6.2..3.

              |1..5...92

              |..7.9.41.""".stripMargin.replaceAll("\\n", "")

type Pos = (Int, Int)

val EmptyValue = '.'

val MaxValue = 9

def pretty(game: String): String = 

  "\n" + (game.grouped(MaxValue).mkString("\n"))

pretty(game0)

val allValues = "123456789".toList

val indexes = (0 to 8).toList

def empty(game: String) = game.indexOf(EmptyValue)

def isDone(game: String) = empty(game) == -1 

def emptyPosition(game: String) : Pos = {

  val e = empty(game)

  (e % MaxValue, e / MaxValue)

}

def get_row(game: String, y: Int) = 

  indexes.map(col => game(y * MaxValue + col))

def get_col(game: String, x: Int) = 

  indexes.map(row => game(x + row * MaxValue))

//get_row(game0, 0)

//get_row(game0, 1)

//get_col(game0, 0)

def get_box(game: String, pos: Pos): List[Char] = {

    def base(p: Int): Int = (p / 3) * 3

    val x0 = base(pos._1)

    val y0 = base(pos._2)

    val ys = (y0 until y0 + 3).toList

    (x0 until x0 + 3).toList

      .flatMap(x => ys.map(y => game(x + y * MaxValue)))

}

//get_box(game0, (3, 1))

// this is not mutable!!

def update(game: String, pos: Int, value: Char): String = 

  game.updated(pos, value)

def toAvoid(game: String, pos: Pos): List[Char] = 

  (get_col(game, pos._1) ++ 

   get_row(game, pos._2) ++ 

   get_box(game, pos))

def candidates(game: String, pos: Pos): List[Char] = 

  allValues.diff(toAvoid(game, pos))

//candidates(game0, (0,0))

def search(game: String): List[String] = {

  if (isDone(game)) List(game)

  else {

    val cs = candidates(game, emptyPosition(game))

    cs.par.map(c => search(update(game, empty(game), c))).flatten.toList

  }

}

pretty(game0)

search(game0).map(pretty)

val game1 = """23.915...

              |...2..54.

              |6.7......

              |..1.....9

              |89.5.3.17

              |5.....6..

              |......9.5

              |.16..7...

              |...329..1""".stripMargin.replaceAll("\\n", "")

search(game1).map(pretty)

// a game that is in the hard category

val game2 = """8........

              |..36.....

              |.7..9.2..

              |.5...7...

              |....457..

              |...1...3.

              |..1....68

              |..85...1.

              |.9....4..""".stripMargin.replaceAll("\\n", "")

search(game2).map(pretty)

// game with multiple solutions

val game3 = """.8...9743

              |.5...8.1.

              |.1.......

              |8....5...

              |...8.4...

              |...3....6

              |.......7.

              |.3.5...8.

              |9724...5.""".stripMargin.replaceAll("\\n", "")

search(game3).map(pretty).foreach(println)

// for measuring time

def time_needed[T](i: Int, code: => T) = {

  val start = System.nanoTime()

  for (j <- 1 to i) code

  val end = System.nanoTime()

  s"${(end - start) / 1.0e9} secs"

}

time_needed(2, search(game2))

// concurrency 

// scala-cli --extra-jars scala-parallel-collections_3-1.0.4.jar 

// import scala.collection.parallel.CollectionConverters._

// String Interpolations

//=======================

def cube(n: Int) : Int = n * n * n

val n = 3

println("The cube of " + n + " is " + cube(n) + ".")

println(s"The cube of $n is ${cube(n)}.")

// or even

println(s"The cube of $n is ${n * n * n}.")

// helpful for debugging purposes

//

//     "The most effective debugging tool is still careful 

//          thought, coupled with judiciously placed print 

//                                             statements."

//       — Brian W. Kernighan, in Unix for Beginners (1979)

def gcd_db(a: Int, b: Int) : Int = {

  println(s"Function called with $a and $b.")

  if (b == 0) a else gcd_db(b, a % b)

}

gcd_db(48, 18)

// Recursion Again ;o)

//====================

// another well-known example: Towers of Hanoi

//=============================================

def move(from: Char, to: Char) =

  println(s"Move disc from $from to $to!")

def hanoi(n: Int, from: Char, via: Char, to: Char) : Unit = {

  if (n == 0) ()

  else {

    hanoi(n - 1, from, to, via)

    move(from, to)

    hanoi(n - 1, via, from, to)

  }

} 

hanoi(4, 'A', 'B', 'C')

// Pattern Matching

//==================

// A powerful tool which has even landed in Java during 

// the last few years (https://inside.java/2021/06/13/podcast-017/).

// ...Scala already has it for many years and the concept is

// older than your friendly lecturer, that is stone old  ;o)

// The general schema:

//

//    expression match {

//       case pattern1 => expression1

//       case pattern2 => expression2

//       ...

//       case patternN => expressionN

//    }

// recall

def len(xs: List[Int]) : Int = {

    if (xs == Nil) 0

    else 1 + len(xs.tail)

}    

def len(xs: List[Int]) : Int = xs match {

    case Nil => 0

    case hd::tail => 1 + len(tail)

}  

def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = 

  lst match {

    case Nil => Nil

    case x::xs => f(x)::my_map_int(xs, f)

  }

def my_map_option(opt: Option[Int], f: Int => Int) : Option[Int] = 

  opt match {

    case None => None

    case Some(x) => Some(f(x))

  }

my_map_option(None, x => x * x)

my_map_option(Some(8), x => x * x)

// you can also have cases combined

def season(month: String) : String = month match {

  case "March" | "April" | "May" => "It's spring"

  case "June" | "July" | "August" => "It's summer"

  case "September" | "October" | "November" => "It's autumn"

  case "December" => "It's winter"

  case "January" | "February" => "It's unfortunately winter"

  case _ => "Wrong month"

}

// pattern-match on integers

def fib(n: Int) : Int = n match { 

  case 0 | 1 => 1

  case n => fib(n - 1) + fib(n - 2)

}

fib(10)

// pattern-match on results

// Silly: fizz buzz

def fizz_buzz(n: Int) : String = (n % 3, n % 5) match {

  case (0, 0) => "fizz buzz"

  case (0, _) => "fizz"

  case (_, 0) => "buzz"

  case _ => n.toString  

}

for (n <- 1 to 20) 

 println(fizz_buzz(n))

// more interesting patterns for lists - calculate the deltas between 

// elements

def delta(xs: List[Int]) : List[Int] = xs match {

  case Nil => Nil

  case x::Nil => x::Nil

  case x::y::xs => (x - y)::delta(y::xs)

}

delta(List(10, 7, 8, 2, 5, 10))

// guards in pattern-matching

def foo(xs: List[Int]) : String = xs match {

  case Nil => s"this list is empty"

  case x :: xs if x % 2 == 0 

     => s"the first elemnt is even"

  case x :: y :: rest if x == y

     => s"this has two elemnts that are the same"

  case hd :: tl => s"this list is standard $hd::$tl"

}

foo(Nil)

foo(List(1,2,3))

foo(List(1,2))

foo(List(1,1,2,3))

foo(List(2,2,2,3))

// Trees

abstract class Tree

case class Leaf(x: Int) extends Tree

case class Node(s: String, left: Tree, right: Tree) extends Tree 

val lf = Leaf(20)

val tr = Node("foo", Leaf(10), Leaf(23))

val lst : List[Tree] = List(lf, tr)

abstract class Colour

case object Red extends Colour 

case object Green extends Colour 

case object Blue extends Colour

case object Yellow extends Colour

def fav_colour(c: Colour) : Boolean = c match {

  case Green => true

  case _  => false 

}

fav_colour(Blue)

enum ChessPiece:

  case Queen, Rook, Bishop, Knight, Pawn

  def value = this match

    case Queen  => 9

    case Rook   => 5

    case Bishop => 3

    case Knight => 3

    case Pawn   => 1

// ... a tiny bit more useful: Roman Numerals

sealed abstract class RomanDigit 

case object I extends RomanDigit 

case object V extends RomanDigit 

case object X extends RomanDigit 

case object L extends RomanDigit 

case object C extends RomanDigit 

case object D extends RomanDigit 

case object M extends RomanDigit 

type RomanNumeral = List[RomanDigit] 

List(X,I,M,A)

/*

I    -> 1

II   -> 2

III  -> 3

IV   -> 4

V    -> 5

VI   -> 6

VII  -> 7