#load "Paket.fsx"

Paket.Package ["FParsec"; "FSharp.Data"]

#r @"packages/FParsec/lib/net40-client/FParsecCS.dll"
#r @"packages/FParsec/lib/net40-client/FParsec.dll"
#r @"packages/FSharp.Data/lib/net40/FSharp.Data.dll"
#r @"packages/FSharp.Data/lib/net40/FSharp.Data.DesignTime.dll"
#r @"packages/Zlib.Portable/lib/portable-net4+sl5+wp8+win8+wpa81+MonoTouch+MonoAndroid/Zlib.Portable.dll"

[<Measure>] type Chapter
[<Measure>] type Verse
[<Measure>] type c = Chapter
[<Measure>] type v = Verse

type ChapterAndVerse =
  { Chapter : int<Chapter>
    Verse : int<Verse> }
  static member Make c v =
    { Chapter = c
      Verse = v }
  override x.ToString () =
    sprintf "%d.%d" (x.Chapter / 1<c>) (x.Verse / 1<v>)

let cv =
  ChapterAndVerse.Make

type Location =
  { Book : string
    ChapterAndVerse : ChapterAndVerse }
  static member Make b c v =
    { Book = b
      ChapterAndVerse = { Chapter = c; Verse = v } }
  override x.ToString () =
     sprintf "%s.%O" x.Book x.ChapterAndVerse

let loc =
  Location.Make

type Range =
  { Book : string
    Start : ChapterAndVerse
    End : ChapterAndVerse }
  static member Make b s e =
    { Book = b
      Start = s
      End = e }
  override x.ToString () =
    sprintf "%s.%O-%s.%O" x.Book x.Start x.Book x.End

let r =
  Range.Make

let contains (range : Range) location =
  let lower = { Location.Book = range.Book; ChapterAndVerse = range.Start }
  let upper = { Location.Book = range.Book; ChapterAndVerse = range.End }
  location >= lower && location <= upper

contains (r "Gen" (cv 1<c> 1<v>) (cv 2<c> 10<v>)) (loc "Gen" 1<c> 2<v>)

contains (r "Gen" (cv 1<c> 1<v>) (cv 2<c> 10<v>)) (loc "Gen" 3<c> 2<v>)

open System.IO
let input =
  File.ReadAllLines <| Path.Combine(__SOURCE_DIRECTORY__, "cross_references.txt")

input

open FParsec

let makeString chars =
  chars |> Array.ofList |> System.String

// parse a location
let plocation =
  let dot = pchar '.'
  let notDot = satisfy (fun c -> c <> '.')
  // Take at least one non-dot character.
  // Build a string from the characters taken.
  // This is the book name.
  (many1 notDot |>> makeString)
  // Check the book name is followed by a dot and
  // then throw it away (.>> only keeps the result
  // from the left)
  .>> dot
  // Parse a int; keep both the book and the int.
  // This is the chapter (.>>. keeps left and right
  // results, puts them in a tuple)
  .>>. pint32
  // As above.
  .>> dot
  // Capture the verse int; we now have a tuple on
  // the left so we end up with a tuple containing
  // a tuple and an int
  .>>. pint32
  // Map the awkward tuple structure into our nice
  // domain type ``Location`` if we've found all of
  // the required data
  |>> (fun ((book, chapter), verse) ->
       loc book (chapter * 1<c>) (verse * 1<v>))

// Parse a range
let prange =
  // In the format above, a range is either a single
  // verse (representation same as a location) or as
  // a start and an end location separated by "-".
  // We'll create a parser for the optional second half
  // first...
  let endOfRange =
    pchar '-'
    // >>. throws away the result from the left
    >>. plocation
  // Here we take the start and optional end location
  // and then map them to our domain type.
  plocation .>>. (opt endOfRange)
  >>= (fun (starting, ending) ->
  fun stream ->
    let ending = defaultArg ending starting
    if starting.Book <> ending.Book then
      Reply(Error, expectedString "Both ends of range should be in the same book")
    else
      r starting.Book starting.ChapterAndVerse ending.ChapterAndVerse
      |> Reply)

// Finally, a row from the text file is just a location
// followed by space, followed by a range, then a space
// and the votes. Spaces and votes are ignored by careful
// use of discarding operators.
let row : Parser<_, unit> =
  plocation
  .>> spaces1
  .>>. prange
  .>> spaces1
  .>> pint32
  .>> eof

"Gen.1.1" |> run plocation

"Gen.1.1-Gen.3.10" |> run prange

"Gen.1.1-Heb.11.3" |> run prange

"Gen.1.1 Heb.11.3    67" |> run row

"Gen.1.1.22  Heb.11.3    67" |> run row

let crossReferences =
  input
  |> Seq.skip 1 // skip the row titles
  |> Seq.map (run row)
  |> Seq.choose (function
                 | Success (reference, _, _) -> Some reference
                 | _ -> None)

crossReferences
|> Seq.take 10
|> Util.Table

type BibleInfo = FSharp.Data.JsonProvider<"./books.js">

let bibleInfo = BibleInfo.Load("./books.js")

let bookMap =
  bibleInfo.Response.Books
  |> Seq.map (fun b -> b.Abbr, b.Name)
  |> Map.ofSeq

bookMap

let story = [
    // Matthew's account
    r "Matt" (cv 1<c> 18<v>) (cv 2<c> 18<v>)

    // Luke's account part 1
    r "Luke" (cv 1<c> 26<v>) (cv 1<c> 56<v>)

    // Luke's account part 2
    r "Luke" (cv 2<c> 1<v>) (cv 2<c> 21<v>)
  ]

let findCrossReferencesOfRange references range =
  references
  |> Seq.filter (fun reference -> contains range <| fst reference)

let allCrossReferences references ranges =
  ranges
  |> Seq.fold (fun found range ->
    Seq.concat [findCrossReferencesOfRange references range;found]) Seq.empty

let christmasRefs =
  allCrossReferences crossReferences story

christmasRefs |> Seq.length

christmasRefs
|> Seq.take 10
|> Util.Table

// count per book, sort by descending
let byBook =
  christmasRefs
  |> Seq.map (fun r -> bookMap.[(snd r).Book])
  |> Seq.countBy id
  |> Seq.sortByDescending snd

byBook |> Seq.take 10 |> Util.Table

// Count how many times a book is referenced from each of our
// source books
let fromBookToBook =
  christmasRefs
  |> Seq.map (fun (from, to') -> bookMap.[from.Book], bookMap.[to'.Book])
  |> Seq.countBy id
  |> Seq.sortByDescending snd

fromBookToBook
|> Seq.take 10
|> Util.Table

let names =
  bibleInfo.Response.Books
  |> Seq.map (fun b -> b.Name)

// Simple string concatination will do the job here,
// for more complex data we could use an actual JSON
// serialization library
let nodes =
  names
  |> Seq.map (fun name -> sprintf "{ id: %A, x: 0, y: 0 }" name)
  |> String.concat ",\n"
  |> sprintf "[%s]"

let links =
  fromBookToBook
  |> Seq.map (fun ((source, target), strength) ->
    let sourceI = Seq.findIndex ((=) source) names
    let targetI = Seq.findIndex ((=) target) names
    sprintf "{ source: %d, target: %d, strength: %d }" sourceI targetI strength)
  |> String.concat ",\n"
  |> sprintf "[%s]"

"""<script src='http://d3js.org/d3.v3.min.js'></script>""" |> Util.Html |> Display

sprintf """
<style>
.node {
    fill: #5cc;
    stroke: #2aa;
    stroke-width: 2px;
}

.link {
    stroke: #777;
    stroke-width: 2px;
}
</style>


<div id="viz"></div>

<script>
var width = 800;
var height = 800;

var nodeData = %s;

var linkData = %s;

var force = null,
    nodes = null,
    nodeTitles = null,
    links = null;

var svg = d3.select('#viz').append('svg')
    .attr('width', width)
    .attr('height', height);
    
var initForce = function() {
    svg.selectAll('*').remove();

    force = d3.layout.force()
        .size([width, height])
        .nodes(nodeData)
        .links(linkData)
        .gravity(0.5)
        .charge([-1000]);
        
    force.linkDistance(function (link) { return 400 / link.strength });

    links = svg.selectAll('.link')
        .data(linkData)
        .enter().append('line')
        .attr('class', 'link');
    
    nodes = svg.selectAll('.node')
        .data(nodeData)
        .enter().append('circle')
        .attr('class', 'node')
        .attr('r', width / 50);
        
    nodeTitles = svg.selectAll('text')
        .data(nodeData)
        .enter().append('text')
        .attr('text-anchor', 'middle')
        .text(function (d) { return d.id })
        .attr('font-family', 'sans')
        .attr('font-size', 16)
        .attr('fill', 'black');
    
    force.on('tick', stepForce);
};

var stepForce = function() {

    nodes.attr('cx', function(d) { return d.x; })
        .attr('cy', function(d) { return d.y; });

    nodeTitles.attr('x', function(d) { return d.x; })
        .attr('y', function(d) { return d.y; });

    links.attr('x1', function(d) { return d.source.x; })
        .attr('y1', function(d) { return d.source.y; })
        .attr('x2', function(d) { return d.target.x; })
        .attr('y2', function(d) { return d.target.y; });
};

initForce();
force.start();
</script>
""" nodes links
|> Util.Html