package types

import (
        "bytes"
        "encoding/gob"
)

type Artist struct {
        Name    string
        URL     string
        ID      string
        Genre   string
        Country string
        Records []Record
}

type ArtistInfo struct {
        Data      Artist
        ExtraData []Artist
}

func EncodeArtist(artist Artist) ([]byte, error) {
        var encodedArtist []byte
        var network bytes.Buffer
        enc := gob.NewEncoder(&network)
        err := enc.Encode(artist)
        if err != nil {
                return encodedArtist, err
        }
        encodedArtist = network.Bytes()
        return encodedArtist, nil
}

func DecodeArtist(encoded []byte) (Artist, error) {
        var artist Artist
        network := bytes.NewBuffer(encoded)
        dec := gob.NewDecoder(network)
        err := dec.Decode(&artist)
        if err != nil {
                return artist, err
        }
        return artist, nil
}

func EncodeArtistInfo(artists ArtistInfo) ([]byte, error) {
        var encodedArtistInfo []byte
        var network bytes.Buffer
        enc := gob.NewEncoder(&network)
        err := enc.Encode(artists)
        if err != nil {
                return encodedArtistInfo, err
        }
        encodedArtistInfo = network.Bytes()
        return encodedArtistInfo, nil
}

func DecodeArtistInfo(encoded []byte) (ArtistInfo, error) {
        var artistinfo ArtistInfo
        network := bytes.NewBuffer(encoded)
        dec := gob.NewDecoder(network)
        err := dec.Decode(&artistinfo)
        if err != nil {
                return artistinfo, err
        }
        return artistinfo, nil
}

package types

import (
        "bytes"
        "encoding/gob"
)

type InfoRetrievalType int

const (
        ArtistName InfoRetrievalType = 1 << iota
        ArtistData
        AlbumName
        AlbumData
        AlbumWithArtistData
)

type InfoRetrieval struct {
        Type   InfoRetrievalType
        Data   []byte
        Artist string
        Album  string
}

func EncodeInfoRetrieval(info InfoRetrieval) ([]byte, error) {
        var encodedInfoRetrieval []byte
        var network bytes.Buffer
        enc := gob.NewEncoder(&network)
        err := enc.Encode(info)
        if err != nil {
                return encodedInfoRetrieval, err
        }
        encodedInfoRetrieval = network.Bytes()
        return encodedInfoRetrieval, nil
}

func DecodeInfoRetrieval(encoded []byte) (InfoRetrieval, error) {
        var info InfoRetrieval
        network := bytes.NewBuffer(encoded)
        dec := gob.NewDecoder(network)
        err := dec.Decode(&info)
        if err != nil {
                return info, err
        }
        return info, nil
}

package types

import (
        "bytes"
        "encoding/gob"
)

type JobType int

const (
        ArtistInfoRetrieval JobType = 1 << iota
        RecordInfoRetrieval
        JobInfoRetrieval
        Die
)

type Job struct {
        ID             string  `json:"id"`
        Finished       bool    `json:"finished"`
        Status         bool    `json:"status"`
        Type           JobType `json:"type"`
        LastOrigin     string  `json:"lastorigin"`
        RequiredOrigin string  `json:"requiredorigin"`
        Data           []byte  `json:"data"`
        Result         []byte  `json:"result"`
        Error          string  `json:"error"`
}

func EncodeJob(job Job) ([]byte, error) {
        var encodedJob []byte
        var network bytes.Buffer
        enc := gob.NewEncoder(&network)
        err := enc.Encode(job)
        if err != nil {
                return encodedJob, err
        }
        encodedJob = network.Bytes()
        return encodedJob, nil
}

func DecodeJob(encoded []byte) (Job, error) {
        var job Job
        network := bytes.NewBuffer(encoded)
        dec := gob.NewDecoder(network)
        err := dec.Decode(&job)
        if err != nil {
                return Job{}, err
        }
        return job, nil
}