//
//  rhrdtime
//
//  The Radio Helsinki Rivendell Time Websocket Server
//
//
//  Copyright (C) 2015 Christian Pointner <equinox@helsinki.at>
//
//  This file is part of rhrdtime.
//
//  rhrdtime is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  any later version.
//
//  rhrdtime is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with rhrdtime. If not, see <http://www.gnu.org/licenses/>.
//

package main

import (
  "fmt"
  "time"
  "flag"
  "net/http"
  "encoding/json"

  "github.com/codegangsta/martini"
  "github.com/gorilla/websocket"
  "github.com/tuxychandru/pubsub"
)

type timeUpdate struct {
  Timestamp int64 `json:"timestamp"`
  Week uint8 `json:"week"`
}

func getTimeUpdate() []byte {
  now := time.Now()

  update := timeUpdate{now.Unix(), 1}
  update_json, err := json.Marshal(update)
  if err != nil {
    fmt.Println(err)
    return []byte{'{', '}'}
  }
  return update_json
}

func goTalkWithClient(w http.ResponseWriter, r *http.Request, ps *pubsub.PubSub) {
  ws, err := websocket.Upgrade(w, r, nil, 1024, 1024)
  if _, ok := err.(websocket.HandshakeError); ok {
    http.Error(w, "Not a websocket handshake", 400)
    return
  } else if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println("Client connected", ws.RemoteAddr())

  timeupdate_chan := ps.Sub("timeupdate")
  defer ps.Unsub(timeupdate_chan, "timeupdate")

  update_json := getTimeUpdate()
  if err := ws.WriteMessage(websocket.TextMessage, update_json); err != nil {
    return
  }

  for jsonupdate := range timeupdate_chan {
    if err := ws.WriteMessage(websocket.TextMessage, jsonupdate.([]byte)); err != nil {
      return
    }
  }
}

func RunMartini(ps *pubsub.PubSub) {
  m := martini.Classic()
  m.Get("/time", func(w http.ResponseWriter, r *http.Request) {
    goTalkWithClient(w, r, ps)
  })

  m.Run()
}

func main() {
  interval_s := flag.String("interval", "15s", "the interval between updates, default: 15s")
  help := flag.Bool("help", false, "show usage")

  flag.Parse()
  if *help {
    flag.Usage()
    return
  }

  interval, err := time.ParseDuration(*interval_s)
  if err != nil {
    fmt.Println(err)
    return
  }

  ps := pubsub.New(1)

  ticker := time.NewTicker(interval)
  go func() {
    for _ = range ticker.C {
      ps.Pub(getTimeUpdate(), "timeupdate")
    }
  }()

  RunMartini(ps)
}