//
//  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 (
	"encoding/json"
	"flag"
	"fmt"
	"math"
	"net/http"
	"time"

	"github.com/go-martini/martini"
	"github.com/gorilla/websocket"
)

func getRDWeekAndOffset(t time.Time) (uint8, int) {
	//
	// This computes the current Rivendell Week based on the number
	// of weeks since epoch.
	//
	// Explanation:
	//  epoch was at 01.01.1970 UTC which was a Thursday.
	//  Monday in that week is (s-from-epoch + 3*24*60*60) seconds ago.
	//  This needs to be adjusted by the timezone offset for Europe/Vienna
	//  which is of course not constant (damn you daylight savings time)
	//  Divide this by (7*24*60*60) and you get the number of
	//  weeks since the Monday in the week of epoch adjusted for timezone offsets.
	//  This week had week number 3 so add an offset of 2 and
	//  get the modulo of 4. This rounded down gives you the current week
	//  with 0 meaning Week 1. So add 1 to that number and you will get
	//  the current RD week.
	//

	loc, err := time.LoadLocation("Europe/Vienna")
	if err != nil {
		fmt.Println(err)
		return 0, 0
	}

	t = t.In(loc)
	_, offset := t.Zone()

	sEpoch := t.Unix() + int64(offset)
	return uint8(math.Floor(math.Mod((((float64(sEpoch)+259200)/604800)+2), 4)) + 1), offset
}

type ntpMessage struct {
	T1       int64 `json:"t1"`
	T2       int64 `json:"t2"`
	T3       int64 `json:"t3"`
	T4       int64 `json:"t4"`
	TZOffset int   `json:"tz_offset"`
	Week     uint8 `json:"week"`
}

func handleNTPClient(w http.ResponseWriter, r *http.Request) {
	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())

	for {
		msgtype, msg, err := ws.ReadMessage()
		if err != nil {
			fmt.Println("Client connected", ws.RemoteAddr())
			return
		}
		now_t2 := time.Now()
		if msgtype == websocket.TextMessage {

			var n ntpMessage
			if err := json.Unmarshal(msg, &n); err != nil {
				fmt.Println("mallformed NTP message", err)
				continue
			}

			n.T2 = (now_t2.Unix() * 1000) + int64(now_t2.Nanosecond()/1000000)
			n.Week, n.TZOffset = getRDWeekAndOffset(now_t2)

			now_t3 := time.Now()
			n.T3 = (now_t3.Unix() * 1000) + int64(now_t3.Nanosecond()/1000000)

			ntp_json, err := json.Marshal(n)
			if err != nil {
				fmt.Println(err)
				continue
			}
			if err := ws.WriteMessage(websocket.TextMessage, ntp_json); err != nil {
				return
			}
		}
	}
}

func RunMartini(addr string) {
	m := martini.Classic()
	m.Get("/ntp", func(w http.ResponseWriter, r *http.Request) {
		handleNTPClient(w, r)
	})

	m.RunOnAddr(addr)
}

func main() {
	addr_s := flag.String("addr", ":3000", "addr:port to listen on, default: ':3000'")
	help := flag.Bool("help", false, "show usage")

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

	RunMartini(*addr_s)
}