package music

import (
    "arimelody-web/model"
)

func (repo *MusicRepositoryPostgres) GetAllArtists() ([]*model.Artist, error) {
    var artists = []*model.Artist{}

    err := repo.db.Select(&artists, "SELECT * FROM artist")
    if err != nil {
        return nil, err
    }

    return artists, nil
}
func (repo *MusicRepositoryPostgres) GetArtistCount() (int, error) {
    var count int
    err := repo.db.Get(&count, "SELECT count(*) FROM artist")
    return count, err
}

func (repo *MusicRepositoryPostgres) GetArtistByID(id string) (*model.Artist, error) {
    var artist = model.Artist{}

    err := repo.db.Get(&artist, "SELECT * FROM artist WHERE id=$1", id)
    if err != nil {
        return nil, err
    }

    return &artist, nil
}

func (repo *MusicRepositoryPostgres) GetArtistsNotOnRelease(releaseID string) ([]*model.Artist, error) {
    var artists = []*model.Artist{}

    err := repo.db.Select(&artists,
        "SELECT * FROM artist "+
        "WHERE id NOT IN "+
        "(SELECT artist FROM musiccredit WHERE release=$1)",
        releaseID)
    if err != nil {
        return nil, err
    }

    return artists, nil
}

func (repo *MusicRepositoryPostgres) GetArtistCredits(artistID string, showHidden bool) ([]*model.Credit, error) {
    var query string = "SELECT release.id,title,artwork,release_date,artist.id,name,website,avatar,role,is_primary "+
        "FROM musiccredit "+
        "JOIN musicrelease AS release ON release=release.id "+
        "JOIN artist ON artist=artist.id "+
        "WHERE artist=$1 "
    if !showHidden { query += "AND visible=true " }
    query += "ORDER BY release_date DESC"
    rows, err := repo.db.Query(query, artistID)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    type NamePrimary struct {
        Name    string  `json:"name"`
        Primary bool    `json:"primary" db:"is_primary"`
    }
    var credits []*model.Credit
    for rows.Next() {
        credit := &model.Credit{
            Release: &model.Release{},
            Artist: &model.Artist{},
        }
        err = rows.Scan(
            &credit.Release.ID,
            &credit.Release.Title,
            &credit.Release.Artwork,
            &credit.Release.ReleaseDate,
            &credit.Artist.ID,
            &credit.Artist.Name,
            &credit.Artist.Website,
            &credit.Artist.Avatar,
            &credit.Role,
            &credit.Primary,
        )

        otherArtists := []NamePrimary{}
        err = repo.db.Select(&otherArtists,
            "SELECT name,is_primary FROM artist "+
            "JOIN musiccredit ON artist=id "+
            "WHERE release=$1",
            credit.Release.ID)
        for _, otherCredit := range otherArtists {
            credit.Release.Credits = append(credit.Release.Credits, &model.Credit{
                Artist: &model.Artist{
                    Name: otherCredit.Name,
                },
                Primary: otherCredit.Primary,
            })
        }

        credits = append(credits, credit)
    }

    return credits, nil
}

func (repo *MusicRepositoryPostgres) CreateArtist(
    id string,
    name string,
    website string,
    avatar string,
) error {
    _, err := repo.db.Exec(
        "INSERT INTO artist (id, name, website, avatar) "+
        "VALUES ($1, $2, $3, $4)",
        id, name, website, avatar,
    )
    return err
}

func (repo *MusicRepositoryPostgres) UpdateArtist(artist *model.Artist) error {
    _, err := repo.db.Exec(
        "UPDATE artist "+
        "SET name=$2, website=$3, avatar=$4 "+
        "WHERE id=$1",
        artist.ID,
        artist.Name,
        artist.Website,
        artist.Avatar,
    )
    return err
}
func (repo *MusicRepositoryPostgres) UpdateArtistID(oldID string, newID string) error {
    _, err := repo.db.Exec("UPDATE artist SET id=$2 WHERE id=$1", oldID, newID)
    return err
}
func (repo *MusicRepositoryPostgres) UpdateArtistName(id string, name string) error {
    _, err := repo.db.Exec("UPDATE artist SET name=$2 WHERE id=$1", id, name)
    return err
}
func (repo *MusicRepositoryPostgres) UpdateArtistWebsite(id string, website string) error {
    _, err := repo.db.Exec("UPDATE artist SET website=$2 WHERE id=$1", id, website)
    return err
}
func (repo *MusicRepositoryPostgres) UpdateArtistAvatar(id string, avatar string) error {
    _, err := repo.db.Exec("UPDATE artist SET avatar=$2 WHERE id=$1", id, avatar)
    return err
}

func (repo *MusicRepositoryPostgres) DeleteArtist(id string) (string, error) {
    var deletedID string
    err := repo.db.Get(&deletedID, "DELETE FROM artist WHERE id=$1", id)
    return deletedID, err
}