//
//  rhctl
//
//  Copyright (C) 2009-2016 Christian Pointner <equinox@helsinki.at>
//
//  This file is part of rhctl.
//
//  rhctl 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.
//
//  rhctl 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 rhctl. If not, see <http://www.gnu.org/licenses/>.
//

package main

import (
	"fmt"
	"strconv"
	"strings"
)

type SwitchUnitID uint

func (u SwitchUnitID) String() string {
	return strconv.FormatUint(uint64(u), 10)
}

func (u *SwitchUnitID) FromString(str string) error {
	vuint, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return err
	}
	if vuint > 3 {
		return fmt.Errorf("switch unit ID is out of range")
	}
	*u = SwitchUnitID(vuint)
	return nil
}

func (u *SwitchUnitID) UnmarshalTOML(data []byte) error {
	return u.FromString(string(data))
}

type SwitchInputNum uint

func (i SwitchInputNum) String() string {
	return strconv.FormatUint(uint64(i), 10)
}

func (i *SwitchInputNum) FromString(str string) error {
	vuint, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return err
	}
	if vuint < 1 || vuint > 8 {
		return fmt.Errorf("switch input number is out of range")
	}
	*i = SwitchInputNum(vuint)
	return nil
}

type SwitchOutputNum uint

func (o SwitchOutputNum) String() string {
	return strconv.FormatUint(uint64(o), 10)
}

func (o *SwitchOutputNum) FromString(str string) error {
	vuint, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return err
	}
	if vuint < 1 || vuint > 2 {
		return fmt.Errorf("switch output number is out of range")
	}
	*o = SwitchOutputNum(vuint)
	return nil
}

type SwitchRelayNum uint

func (r SwitchRelayNum) String() string {
	return strconv.FormatUint(uint64(r), 10)
}

func (r *SwitchRelayNum) FromString(str string) error {
	vuint, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return err
	}
	if vuint < 1 || vuint > 8 {
		return fmt.Errorf("switch relay number is out of range")
	}
	*r = SwitchRelayNum(vuint)
	return nil
}

type SwitchOCNum uint

func (o SwitchOCNum) String() string {
	return strconv.FormatUint(uint64(o), 10)
}

func (o *SwitchOCNum) FromString(str string) error {
	vuint, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return err
	}
	if vuint < 1 || vuint > 8 {
		return fmt.Errorf("switch OC number is out of range")
	}
	*o = SwitchOCNum(vuint)
	return nil
}

type SwitchCmdString string

const (
	SwitchCmdStatusAudio   SwitchCmdString = "*uSL"
	SwitchCmdStatusGPI     SwitchCmdString = "*uSPA"
	SwitchCmdStatusOC      SwitchCmdString = "*uSO"
	SwitchCmdStatusRelay   SwitchCmdString = "*uSR"
	SwitchCmdStatusSilence SwitchCmdString = "*uSS"

	SwitchCmdAudioSelectInput      SwitchCmdString = "*uiio"
	SwitchCmdAudioSelectInputAll   SwitchCmdString = "*uiiA"
	SwitchCmdAudioAddInputTo1      SwitchCmdString = "*uii3"
	SwitchCmdAudioAddInputTo2      SwitchCmdString = "*uii4"
	SwitchCmdAudioRemoveInputFrom1 SwitchCmdString = "*uii5"
	SwitchCmdAudioRemoveInputFrom2 SwitchCmdString = "*uii6"
	SwitchCmdAudioMuteInput        SwitchCmdString = "*uiiMo"
	SwitchCmdAudioMuteInputAll     SwitchCmdString = "*uiiMA"
	SwitchCmdAudioMuteOutput       SwitchCmdString = "*uMo"
	SwitchCmdAudioMuteOutputAll    SwitchCmdString = "*uMA"

	SwitchCmdAudioFadeUpInput   SwitchCmdString = "*uFUii"
	SwitchCmdAudioFadeDownInput SwitchCmdString = "*uFDii"

	SwitchCmdOCUnlatch SwitchCmdString = "*uOOcF"
	SwitchCmdOCLatch   SwitchCmdString = "*uOOcL"
	SwitchCmdOCPulse   SwitchCmdString = "*uOOcP"

	SwitchCmdRelayUnlatch SwitchCmdString = "*uORrF"
	SwitchCmdRelayLatch   SwitchCmdString = "*uORrL"
	SwitchCmdRelayPulse   SwitchCmdString = "*uORrP"
)

func (c SwitchCmdString) Generate(args ...interface{}) string {
	s := string(c)
	for _, arg := range args {
		switch arg.(type) {
		case SwitchUnitID:
			s = strings.Replace(s, "u", fmt.Sprintf("%1d", arg.(SwitchUnitID)), -1)
		case SwitchInputNum:
			s = strings.Replace(s, "ii", fmt.Sprintf("%02d", arg.(SwitchInputNum)), -1)
		case SwitchOutputNum:
			s = strings.Replace(s, "o", fmt.Sprintf("%1d", arg.(SwitchOutputNum)), -1)
		case SwitchRelayNum:
			s = strings.Replace(s, "r", fmt.Sprintf("%1d", arg.(SwitchRelayNum)), -1)
		case SwitchOCNum:
			s = strings.Replace(s, "c", fmt.Sprintf("%1d", arg.(SwitchOCNum)), -1)
		}
	}
	return s
}

type SwitchCommand struct {
	Cmd      SwitchCmdString
	Args     []interface{}
	Response chan<- interface{}
}

func SwitchCommandParseStatus(args []string) (cmdstr SwitchCmdString, cmdargs []interface{}, err error) {
	if len(args) == 0 {
		err = fmt.Errorf("missing argument <status-type>")
		return
	}
	switch args[0] {
	case "audio":
		cmdstr = SwitchCmdStatusAudio
	case "gpi":
		cmdstr = SwitchCmdStatusGPI
	case "oc":
		cmdstr = SwitchCmdStatusOC
	case "relay":
		cmdstr = SwitchCmdStatusRelay
	case "silence":
		cmdstr = SwitchCmdStatusSilence
	default:
		err = fmt.Errorf("unknown status-type: '%s'", args[0])
		return
	}
	return
}

func NewSwitchCommandFromStrings(cmd string, args ...string) (c *SwitchCommand, err error) {
	c = &SwitchCommand{}
	switch cmd {
	case "status":
		c.Cmd, c.Args, err = SwitchCommandParseStatus(args)
	default:
		return nil, fmt.Errorf("unknown command '%s'", cmd)
	}
	return
}