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

package mixer

import (
	"errors"
	"log"
	"strings"

	"github.com/scgolang/midi"
)

type Channel uint8
type FaderLevel uint8

type Mixer struct {
	DevIn  *midi.Device
	DevOut *midi.Device
}

// TODO: make this confgurable
const (
	CC_MUTE  = byte(0xB1)
	CC_FADER = byte(0xB0)

	FaderLevelMax = FaderLevel(0x7F)
	FaderLevel0db = FaderLevel(0x60)
	FaderLevelOff = FaderLevel(0x00)
)

func openDevice(devices []*midi.Device, prefix string) (d *midi.Device, err error) {
	for _, device := range devices {
		if strings.HasPrefix(device.Name, prefix) {
			d = device
		}
	}
	if d == nil {
		return nil, errors.New("could not find device with prefix " + prefix)
	}
	return d, d.Open()
}

func NewMixer(c Config) (*Mixer, error) {
	devices, err := midi.Devices()
	if err != nil {
		return nil, err
	}

	m := &Mixer{}
	if m.DevIn, err = openDevice(devices, c.DevIn); err != nil {
		return nil, err
	}
	if m.DevOut, err = openDevice(devices, c.DevOut); err != nil {
		return nil, err
	}

	m.DevIn.QueueSize = 100
	m.DevOut.QueueSize = 100
	return m, nil
}

func (m *Mixer) handleMidiPacket(p midi.Packet) {
	switch p.Data[0] {
	case CC_FADER:
		log.Printf("mixer: fader movement on channel 0x%02X, level is now: 0x%02X", p.Data[1], p.Data[2])
	case CC_MUTE:
		newState := "unmuted"
		if p.Data[2] > 0 {
			newState = "muted"
		}
		log.Printf("mixer: channel 0x%02X is now %s", p.Data[1], newState)
	}
	// TODO: send new state to subscribers
}

func (m *Mixer) Init() error {
	ch, err := m.DevIn.Packets()
	if err != nil {
		return err
	}

	go func() {
		for {
			m.handleMidiPacket(<-ch)
		}
	}()
	return nil
}

func (m *Mixer) Shutdown() error {
	if m.DevIn != nil {
		m.DevIn.Close()
	}
	if m.DevOut != nil {
		m.DevOut.Close()
	}
	return nil
}

func (m *Mixer) sendMute(channel byte, value byte) error {
	n, err := m.DevOut.Write([]byte{CC_MUTE, channel, value})
	if err != nil {
		return err
	}
	if n != 3 {
		return errors.New("sending mute command failed.")
	}
	return nil
}

func (m *Mixer) Mute(ch Channel) error {
	return m.sendMute(byte(ch), 0x7F)
}

func (m *Mixer) UnMute(ch Channel) error {
	return m.sendMute(byte(ch), 0x00)
}

func (m *Mixer) SetLevel(ch Channel, level FaderLevel) error {
	if level > FaderLevelMax {
		level = FaderLevelMax
	}
	n, err := m.DevOut.Write([]byte{CC_FADER, byte(ch), byte(level)})
	if err != nil {
		return err
	}
	if n != 3 {
		return errors.New("setting fader level failed.")
	}
	return nil
}