// spaceapi.go
package spaceapi

import (
	"encoding/json"
	"time"
)

const max_num_events int = 4

type SpaceInfo map[string]interface{}

func (nsi SpaceInfo) UpdateSensorData(what, where, value string) {
	if nsi["sensors"] == nil {
		sensorlist := make([]SpaceInfo, 1)
		sensorlist[0] = SpaceInfo{what: SpaceInfo{where: value}}
		nsi["sensors"] = sensorlist
	} else {
		sensorlist, ok := nsi["sensors"].([]SpaceInfo) //type assertion (panics if false)
		if ok {
			for _, sensor := range sensorlist {
				if sensor[what] != nil {
					sensorinfo, ok2 := sensor[what].(SpaceInfo)
					if ok2 {
						sensorinfo[where] = value
						return
					} else {
						panic("Wrong Type of sensorinfo: Should never happen")
					}
				}
			}
			//else
			nsi["sensors"] = append(sensorlist, SpaceInfo{what: SpaceInfo{where: value}})
		} else {
			panic("Wrong Type of sensorlist: Should never happen")
		}
	}
}

func (nsi SpaceInfo) AddSpaceContactInfo(phone, irc, email, ml, jabber, issuemail string) SpaceInfo {
	nsi["contact"] = SpaceInfo{
		"phone":  phone,
		"email":  email,
		"ml":     ml,
		"jabber": jabber,
        "issue-mail": issuemail}
    nsi["issue-report-channels"] = [3]string{"issue-mail","email","ml"}
	return nsi
}

func (nsi SpaceInfo) AddSpaceFeed(name, mimetype, url string) SpaceInfo {
	newfeed := SpaceInfo{"name": name, "type": mimetype, "url": url}
	if nsi["feeds"] == nil {
		feedlist := make([]SpaceInfo, 1)
		feedlist[0] = newfeed
		nsi["feeds"] = feedlist
	} else {
		feedlist, ok := nsi["feeds"].([]SpaceInfo) //type assertion (panics if false)
		if ok {
			nsi["feeds"] = append(feedlist, newfeed)
		} else {
			panic("Wrong Type of feedlist: Should never happen")
		}
	}
	return nsi
}

func (nsi SpaceInfo) AddSpaceEvent(name, eventtype, extra string) SpaceInfo {
	newevent := SpaceInfo{"name": name, "type": eventtype, "timestamp": time.Now().Unix(), "extra": extra}
	if nsi["events"] == nil {
		eventlist := make([]SpaceInfo, 1)
		eventlist[0] = newevent
		nsi["events"] = eventlist
	} else {
		eventlist, ok := nsi["events"].([]SpaceInfo) //type assertion
		if ok {
			if len(eventlist) >= max_num_events {
				eventlist = eventlist[1:]
			}
			nsi["events"] = append(eventlist, newevent)
		} else {
			panic("Wrong Type of eventlist: Should never happen")
		}
	}
	return nsi
}

func (nsi SpaceInfo) AddSpaceAddress(address string) SpaceInfo {
	nsi["address"] = address
    if nsi["location"] != nil {
        location, ok := nsi["location"].(SpaceInfo)
        if ok {
            location["address"] = address
        }
    }
	return nsi
}

func (nsi SpaceInfo) SetStatus(open bool, status string) {
	nsi["status"] = status
	nsi["open"] = open
	nsi["lastchange"] = time.Now().Unix()
    state, ok := nsi["state"].(SpaceInfo)
    if ok {
        state["message"] = status
        state["open"] = open
        state["lastchange"] = nsi["lastchange"]
    }
}

func NewSpaceInfo(space string, url string, logo string, open_icon string, closed_icon string, lat float64, lon float64) SpaceInfo {
	nsi := map[string]interface{}{
		"api":        "0.13",
		"space":      space,
		"url":        url,
		"logo":       logo,
		"open":       false,
		"lastchange": time.Now().Unix(),
		"icon":       SpaceInfo{
            "open":     open_icon,
            "closed":   closed_icon,
        },
        "state":       SpaceInfo{
            "open":      false,
            "lastchange":time.Now().Unix(),
            "icon":     SpaceInfo{
                "open":     open_icon,
                "closed":   closed_icon},
            },
        "location":   SpaceInfo{
            "lat":      lat,
            "lon":      lon},
        "contact" :   SpaceInfo {},
    }
	return nsi
}

func (data SpaceInfo) MakeJSON() ([]byte, error) {
	msg, err := json.Marshal(data)
	if err == nil {
		return msg, nil
	}
	return nil, err
}