package main

import (
	"bufio"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"log"
	"os"
)

const fname = "/home/rob/share/home-office/example.mp3"

type (
	AudioVersionId int
	LayerIndex     int

	header uint32
)

const (
	AudioVersionMPEG25 AudioVersionId = iota
	AudioVersionReserved
	AudioVersionMPEG2
	AudioVersionMPEG1
)

const (
	LayerIndexReserved LayerIndex = iota
	LayerIndexIII
	LayerIndexII
	LayerIndexI
)

var (
	bitRates = [5][16]uint32{
		{0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0},
		{0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0},
		{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
		{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},
		{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
	}

	sampleRates = [4][4]uint32{
		{11025, 12000, 8000, 0},
		{0, 0, 0, 0},
		{22050, 24000, 16000, 0},
		{44100, 48000, 32000, 0},
	}

	samplesPerFrame = [4][4]uint32{
		{0, 384, 1152, 576},
		{0, 0, 0, 0},
		{384, 1152, 576},
		{384, 1152, 1152},
	}
)

// TODO tests
func (h header) HasSyncWord() bool {
	return (h>>21)&0x7ff == 0x7ff
}

func (h header) AudioVersionId() AudioVersionId {
	return AudioVersionId((h >> 19) & 0x3)
}

func (h header) LayerIndex() LayerIndex {
	return LayerIndex(((h >> 8) & 0x6) >> 1)
}

func (h header) IsProtected() bool {
	return (h>>8)&1 == 1
}

func (h header) SampleRate() uint32 {
	i := h.AudioVersionId()
	j := (h >> 18) & 0xb11
	return sampleRates[i][j]
}

func (h header) IsValid() bool {
	if !h.HasSyncWord() {
		return false
	}
	if h.AudioVersionId() == AudioVersionReserved {
		return false
	}
	if h.LayerIndex() == LayerIndexReserved {
		return false
	}
	if h.BitRate() == 0 {
		return false
	}

	return true
}

func (h header) BitRate() uint32 {
	var j int
	switch h.AudioVersionId() {
	case AudioVersionMPEG1:
		switch h.LayerIndex() {
		case LayerIndexIII:
			j = 2
		case LayerIndexII:
			j = 1
		case LayerIndexI:
			j = 0
		default:
			return 0
		}
	case AudioVersionReserved:
		return 0
	case AudioVersionMPEG2, AudioVersionMPEG25:
		switch h.LayerIndex() {
		case LayerIndexIII, LayerIndexII:
			j = 4
		case LayerIndexI:
			j = 3
		default:
			return 0

		}
	}
	k := ((h >> 20) & 0xf)
	return bitRates[j][k]
}

func main() {
	f, err := os.Open(fname)
	if err != nil {
		log.Fatal(err)
	}

	bufreader := bufio.NewReader(f)
	buf := make([]byte, 4)

	var i int
	for {
		_, err := io.ReadFull(bufreader, buf)
		if err != nil {
			if err == io.EOF {
				break
			}
			log.Fatal(err)
		}

		header, err := newHeaderFromBytes(buf)
		if header.IsValid() {
			fmt.Printf("%+v\n", buf)
			fmt.Printf("Got header: %032b, audio version: %d, layer index: %d, bitrate: %d\n", header, header.AudioVersionId(), header.LayerIndex(), header.BitRate())
		} else {
			bufreader.Discard(3)
		}
		i++
	}
}

func newHeaderFromBytes(buf []byte) (header, error) {
	if len(buf) < 4 {
		return 0, errors.New("insufficient bytes")
	}
	// assume little-endian for now
	return newHeader(binary.LittleEndian.Uint32(buf))
}

// TODO use unsafe here? https://codereview.stackexchange.com/a/60161
func newHeader(n uint32) (header, error) {
	return header(n), nil
}