package models

import (
	"encoding/json"
)

// Credits represents track credits
type Credits struct {
	BaseModel
	Items []Credit `json:"items"`
	Total int      `json:"total"`
}

// DeJSON deserializes Credits from JSON
func (c *Credits) DeJSON(data []byte, client ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	credits := &Credits{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["items"]; ok {
		var items []Credit
		json.Unmarshal(v, &items)
		credits.Items = items
	}
	if v, ok := raw["total"]; ok {
		json.Unmarshal(v, &credits.Total)
	}

	return credits, nil
}

// DeList deserializes a list of Credits
func (c *Credits) DeList(data []byte, client ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		credits := &Credits{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, credits); err != nil {
			continue
		}
		result = append(result, credits)
	}
	return result, nil
}

// Credit represents a credit
type Credit struct {
	BaseModel
	Role       string `json:"role"`
	Name       string `json:"name"`
	ArtistID   string `json:"artist_id"`
	ArtistName string `json:"artist_name"`
	IsMain     bool   `json:"is_main"`
	TrackID    string `json:"track_id"`
	AlbumID    string `json:"album_id"`
}

// DeJSON deserializes a Credit from JSON
func (c *Credit) DeJSON(data []byte, client ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	credit := &Credit{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["role"]; ok {
		json.Unmarshal(v, &credit.Role)
	}
	if v, ok := raw["name"]; ok {
		json.Unmarshal(v, &credit.Name)
	}
	if v, ok := raw["artist_id"]; ok {
		json.Unmarshal(v, &credit.ArtistID)
	}
	if v, ok := raw["artist_name"]; ok {
		json.Unmarshal(v, &credit.ArtistName)
	}
	if v, ok := raw["is_main"]; ok {
		json.Unmarshal(v, &credit.IsMain)
	}
	if v, ok := raw["track_id"]; ok {
		json.Unmarshal(v, &credit.TrackID)
	}
	if v, ok := raw["album_id"]; ok {
		json.Unmarshal(v, &credit.AlbumID)
	}

	return credit, nil
}

// DeList deserializes a list of Credits
func (c *Credit) DeList(data []byte, client ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		credit := &Credit{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, credit); err != nil {
			continue
		}
		result = append(result, credit)
	}
	return result, nil
}

// LicenceTextPart represents a licence text part
type LicenceTextPart struct {
	BaseModel
	Text     string `json:"text"`
	Language string `json:"language"`
	URL      string `json:"url"`
	Title    string `json:"title"`
	IsMain   bool   `json:"is_main"`
}

// DeJSON deserializes a LicenceTextPart from JSON
func (ltp *LicenceTextPart) DeJSON(data []byte, client ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	part := &LicenceTextPart{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["text"]; ok {
		json.Unmarshal(v, &part.Text)
	}
	if v, ok := raw["language"]; ok {
		json.Unmarshal(v, &part.Language)
	}
	if v, ok := raw["url"]; ok {
		json.Unmarshal(v, &part.URL)
	}
	if v, ok := raw["title"]; ok {
		json.Unmarshal(v, &part.Title)
	}
	if v, ok := raw["is_main"]; ok {
		json.Unmarshal(v, &part.IsMain)
	}

	return part, nil
}

// DeList deserializes a list of LicenceTextPart
func (ltp *LicenceTextPart) DeList(data []byte, client ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		part := &LicenceTextPart{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, part); err != nil {
			continue
		}
		result = append(result, part)
	}
	return result, nil
}