tvmaze.tcl

#######################
## tvmaze.tcl
###############################################################################
# TVMaze.com eggdrop script for those without package json or http, otherwise
# this is one much better: http://forum.egghelp.org/viewtopic.php?t=20045
# get show info: !tvm show
# with summary:  !tvm show -s
# get ep info:   !tvm show 1x01 or !tvm show 2015-10-03
###############################################################################

# bindings
bind pub - "!tvm" pub:tvm
bind msg - "tvm" msg:tvm

# globals
set curl_link [exec which curl]
set dest ""
setudef flag tvm

# procedures
proc pub:tvm {nick host hand chan arg} {
  if {![channel get $chan tvm]} {return}
  set ::dest $chan
  tvm:main $nick $host $hand $arg
}

proc msg:tvm {nick host hand arg} {
  set ::dest $nick
  tvm:main $nick $host $hand $arg
}

proc tvm:main {nick host hand arg} {
  global dest
  putlog "-> tvmaze:\0033 $nick\003 queries \0037\"$arg\"\003 for\0033 $dest\003"
  if {[regexp {(.*) (\d+x\d+|\d+-\d+-\d+)} $arg -> show_name show_episode]} {
    tvm:get_episode $show_name $show_episode $nick
  } else {
    tvm:get_series $arg $nick
  }
}

proc tvm:get_series {show nick} {
  global dest
  global curl_link
  if [regexp {\s\-s} $show] {
    regsub -all {\s\-s} $show "" show
    set getsummary 1
  } else {
    set getsummary 0
  }
  set url {http://api.tvmaze.com/singlesearch/shows?embed[]=previousepisode&embed[]=nextepisode&q=}
  putlog "-> tvmaze: $url"
  append url [tvm:encode_url [string trimleft $show]]
  if {[catch {set data [exec $curl_link --compressed -s -g "$url"]} errmsg]} {
    putlog "-> tvmaze: error loading page - $errmsg."
    putserv "PRIVMSG $nick :\[TVM\] Sorry, the info can't be retrieved right now, try again later."
    return 0
  }
    array set series {
    name "-" url "-" type "-" genres "-" status "-" premiered "-"
    network "-" country "-" airtime "-" airdays "-" summary "" tvrage "-" tvdb "-"
    prev_ep_season "-" prev_ep_number "-" prev_ep_title "-" prev_ep_date "-"
    next_ep_season "-" next_ep_number "-" next_ep_title "-" next_ep_date "-"
  }
  set embedded ""

  regexp {\"url\":\"(.*?)\"} $data -> series(url)
  regexp {\"name\":\"(.*?)\"} $data -> series(name)
  regexp {\"type\":\"(.*?)\"} $data -> series(type)
  regexp {\"genres\":\[(\".+?)\]} $data -> series(genres)
  regexp {\"status\":\"(.*?)\"} $data -> series(status)
  regexp {\"premiered\":\"(.*?)\"} $data -> series(premiered)
  regexp {\"network\":.*?\"name\":\"(.*?)\"} $data -> series(network)
  regexp {\"country\":.*?\"code\":\"(.*?)\"} $data -> series(country)
  regexp {\"schedule\":\{\"time\":\"(\d.*?)\"} $data -> series(airtime)
  regexp {\"schedule\":.*?\"days\":\[(\".*?)\]} $data -> series(airdays)
  regexp {\"tvrage\":(null|\d+)} $data -> series(tvrage)
  regexp {\"thetvdb\":(null|\d+)} $data -> series(tvdb)

  regexp {\"_embedded\":(.*)} $data -> embedded
  regexp {\"previousepisode\":.*?\"name\":\"(.*?)\",\"} $embedded -> series(prev_ep_title)
  regexp {\"previousepisode\":.*?\"season\":(\d+),} $embedded -> series(prev_ep_season)
  regexp {\"previousepisode\":.*?\"number\":(\d+),} $embedded -> series(prev_ep_number)
  regexp {\"previousepisode\":.*?\"airdate\":\"(.*?)\"} $embedded -> series(prev_ep_date)
  regexp {\"nextepisode\":.*?\"name\":\"(.*?)\",\"} $embedded -> series(next_ep_title)
  regexp {\"nextepisode\":.*?\"season\":(\d+),} $embedded -> series(next_ep_season)
  regexp {\"nextepisode\":.*?\"number\":(\d+),} $embedded -> series(next_ep_number)
  regexp {\"nextepisode\":.*?\"airdate\":\"(.*?)\"} $embedded -> series(next_ep_date)

  if {$series(name) == "-"} {
    putserv "NOTICE $nick :\[TVM\] No show matching \0037\"$show\"\003 was found."
    return 0
  }
  regsub -all {\\} $series(name) "" series(name)

  # format output
    if {$series(type) == "-" && $series(genres) == "-"} {
    set type_info ""
  } else {
    set type_info $series(type)
    if {$series(genres) != "-"} {
      set type_info "$type_info | [tvm:format_list $series(genres)]"
    }
    set type_info " ($type_info) "
  }
  if {$series(prev_ep_number) == "-"} {
    set prev_ep_info "-N/A-"
  } else {
    regsub -all {\\} $series(prev_ep_title) "" series(prev_ep_title)
    set prev_ep_info "[format {%02dx%02d} $series(prev_ep_season) $series(prev_ep_number)] - $series(prev_ep_title) ($series(prev_ep_date))"
  }
  if {$series(next_ep_number) == "-"} {
    set next_ep_info "-N/A-"
  } else {
    regsub -all {\\} $series(next_ep_title) "" series(next_ep_title)
    set next_ep_info "[format {%02dx%02d} $series(next_ep_season) $series(next_ep_number)] - $series(next_ep_title) ($series(next_ep_date))"
  }

  # series info
  putserv "PRIVMSG $dest :\002< \002\0037Show:\003\002 $series(name)\002$type_info\0037:: Premiered:\003 $series(premiered) \0037:: Last Episode:\003 $prev_ep_info \0037:: Next Episode:\003 $next_ep_info \0037:: Airtime:\003 [tvm:format_list $series(airdays)] at $series(airtime) ($series(network)) \0037:: Status:\003 $series(status) \0037:: TVRage:\003 $series(tvrage) \0037:: TVDB:\003 $series(tvdb) \0037:: URL:\003 $series(url)\002 >\002"

  # series summary
  if {$getsummary == 1 && [regexp {\"summary\":\"(.*?)\",\"} $data -> series(summary)]} {
    set series(summary) [tvm:clean_summary $series(summary)]
    if {$series(summary) != ""} {
      set series(summary) [tvm:truncate $series(summary) 60]
    } else {
      set series(summary) "none available"
    }
    set output "\002< \002\0037Show Summary:\003 $series(summary)\002 >\002"
    foreach line [tvm:wordwrap $output 425 "PRIVMSG $dest :"] {
      putserv "$line"
    }
  }
}

proc tvm:get_episode {show_name show_episode nick} {
  global dest
  global curl_link

  # get series ID
    set url "http://api.tvmaze.com/singlesearch/shows?q="
  append url [tvm:encode_url [string trimleft $show_name]]
  if {[catch {set data [exec $curl_link --compressed -s -g "$url"]} errmsg]} {
    putlog "-> tvmaze: error loading page - $errmsg."
    putserv "PRIVMSG $nick :\[TVM\] Sorry, the info can't be retrieved right now, try again later."
    return 0
  }
  array set series {
    id "" name "-" url "-"
  }
  regexp {\"id\":(\d+)} $data -> series(id)
  regexp {\"url\":\"(.*?)\"} $data -> series(url)
  regexp {\"name\":\"(.*?)\",\"} $data -> series(name)
  if {$series(id) == ""} {
    putserv "PRIVMSG $nick :\[TVM\] Sorry, no show found with that name."
    return 0
  }
  regsub -all {\\} $series(name) "" series(name)

  # get episode info
  array set episode {
    season 0 number 0 url "-" title "-" airdate "-" summary "-"
  }
  if {[regexp {(\d+)x(\d+)} $show_episode -> episode(season) episode(number)]} {
    set url "http://api.tvmaze.com/shows/$series(id)/episodebynumber?season=$episode(season)&number=$episode(number)"
  } else {
    set url "http://api.tvmaze.com/shows/$series(id)/episodesbydate?date=$show_episode"
  }
  if {[catch {set data [exec $curl_link --compressed -s -g "$url"]} errmsg]} {
    putlog "-> tvmaze: error loading page - $errmsg."
    putserv "PRIVMSG $nick :\[TVM\] Sorry, the info can't be retrieved right now, try again later."
    return 0
  }
  regexp {\"url\":\"(.*?)\"} $data -> episode(url)
  regexp {\"name\":\"(.*?)\",\"} $data -> episode(title)
  regexp {\"season\":(\d+)} $data -> episode(season)
  regexp {\"number\":(\d+)} $data -> episode(number)
  regexp {\"airdate\":\"(.*?)\"} $data -> episode(airdate)
  regexp {\"summary\":\"(.*?)\",\"} $data -> episode(summary)
  regsub -all {\\} $episode(title) "" episode(title)
  if {$episode(summary) != ""} {
    set episode(summary) [tvm:clean_summary $episode(summary)]
    set episode(summary) [tvm:truncate $episode(summary) 60]
  } else {
    set episode(summary) "none available"
  }

  # paged output
  set output "\002< \002\0037Show:\003\002 $series(name) \002\0037:: Episode:\003\002 [format {%02dx%02d} $episode(season) $episode(number)] - $episode(title) ($episode(airdate)) \002\0037:: Summary:\003 $episode(summary) \0037:: Episode URL:\003 $episode(url)\002 >\002"
  foreach line [tvm:wordwrap $output 425 "PRIVMSG $dest :"] {
    putserv "$line"
  }
}

proc tvm:encode_url {str} {
  set str [string map {" " +} $str]
  foreach c [split $str {}] {
    if {$c == "+" || [string is alnum $c]} {append x $c} {
      binary scan $c H2 c; append x %$c
    }
  }
  return $x
}

proc tvm:format_list {str} {
  regsub -all \" $str "" str
  regsub -all "," $str ", " str
  return $str
}

proc tvm:clean_summary {str} {
  regsub -all {\\"} $str {"} str
  regsub -all {<.*?>} $str "" str
  regsub -all {\s{2,}} $str " " str
  return $str
}

proc tvm:truncate {str {len 60}} {
  set i 0; set out "";
  foreach word [split $str " "] {
    if {[incr i] < $len} {lappend out $word} else {break}
  }
  set out [join $out " "]
  if {$i == $len} {
    append out " \[...\]"
  }
  return $out
}

proc tvm:wordwrap {str {len 200} {prefix {}} {splitChr { }}} {
  set out {}
  set cur $prefix
  set i 0
  foreach word [split [set str][unset str] $splitChr] {
    if {[incr i [string len $word]]>$len} {
      lappend out [join $cur $splitChr]
      set out [string map {" : " " :"} $out]
      if {[regexp {^.*(\003\d\d)} $cur -> lastColor]} {
        set cur [join [list $prefix $lastColor $word] ""]
      } else {
        set cur [join [list $prefix $word] ""]
      }
      set i [string len $word]
    } else {
      lappend cur $word
    }
    incr i
  }
  lappend out [join $cur $splitChr]
  set out [string map {" : " " :"} $out]
}

# log
putlog "tvmaze (1.8) loaded ..."