yandex-music-api-go/internal/models/track_short.go

package models

import (
	"encoding/json"
)

// TrackShort represents a lightweight track (used in lists)
type TrackShort struct {
	BaseModel
	ID                       string            `json:"id"`
	Title                    string            `json:"title"`
	DurationMs               int               `json:"duration_ms"`
	StorageID                string            `json:"storage_id"`
	CoverURI                 string            `json:"cover_uri"`
	Artists                  []Artist          `json:"artists"`
	Albums                   []Album           `json:"albums"`
	Genre                    string            `json:"genre"`
	Version                  string            `json:"version"`
	Explicit                 bool              `json:"explicit"`
	Available                bool              `json:"available"`
	AvailableForPremiumUsers bool              `json:"available_for_premium_users"`
	R128                     float64           `json:"r128"`
	TrackSharingFlag         string            `json:"track_sharing_flag"`
	Major                    *Major            `json:"major"`
	Lyrics                   *SupplementLyrics `json:"lyrics"`
	SimilarTracks            []TrackShort      `json:"similar_tracks"`
	DownloadInfo             []DownloadInfo    `json:"download_info"`
	// Additional fields from track_short.py
	Position            *TrackPosition `json:"position"`
	AvailableAsRingtone bool           `json:"available_as_ringtone"`
	RingtoneID          string         `json:"ringtone_id"`
}

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

	track := &TrackShort{BaseModel: *NewBaseModel(c)}

	// Simple fields
	if v, ok := raw["id"]; ok {
		json.Unmarshal(v, &track.ID)
	}
	if v, ok := raw["title"]; ok {
		json.Unmarshal(v, &track.Title)
	}
	if v, ok := raw["duration_ms"]; ok {
		json.Unmarshal(v, &track.DurationMs)
	}
	if v, ok := raw["storage_id"]; ok {
		json.Unmarshal(v, &track.StorageID)
	}
	if v, ok := raw["cover_uri"]; ok {
		json.Unmarshal(v, &track.CoverURI)
	}
	if v, ok := raw["genre"]; ok {
		json.Unmarshal(v, &track.Genre)
	}
	if v, ok := raw["version"]; ok {
		json.Unmarshal(v, &track.Version)
	}
	if v, ok := raw["explicit"]; ok {
		json.Unmarshal(v, &track.Explicit)
	}
	if v, ok := raw["available"]; ok {
		json.Unmarshal(v, &track.Available)
	}
	if v, ok := raw["available_for_premium_users"]; ok {
		json.Unmarshal(v, &track.AvailableForPremiumUsers)
	}
	if v, ok := raw["r128"]; ok {
		json.Unmarshal(v, &track.R128)
	}
	if v, ok := raw["track_sharing_flag"]; ok {
		json.Unmarshal(v, &track.TrackSharingFlag)
	}
	if v, ok := raw["available_as_ringtone"]; ok {
		json.Unmarshal(v, &track.AvailableAsRingtone)
	}
	if v, ok := raw["ringtone_id"]; ok {
		json.Unmarshal(v, &track.RingtoneID)
	}

	// Nested objects
	if v, ok := raw["artists"]; ok {
		var artists []Artist
		if err := json.Unmarshal(v, &artists); err == nil {
			track.Artists = artists
		}
	}
	if v, ok := raw["albums"]; ok {
		var albums []Album
		if err := json.Unmarshal(v, &albums); err == nil {
			track.Albums = albums
		}
	}
	if v, ok := raw["major"]; ok {
		var major Major
		if err := json.Unmarshal(v, &major); err == nil {
			track.Major = &major
		}
	}
	if v, ok := raw["lyrics"]; ok {
		var lyrics SupplementLyrics
		if err := json.Unmarshal(v, &lyrics); err == nil {
			track.Lyrics = &lyrics
		}
	}
	if v, ok := raw["similar_tracks"]; ok {
		var similar []TrackShort
		if err := json.Unmarshal(v, &similar); err == nil {
			track.SimilarTracks = similar
		}
	}
	if v, ok := raw["download_info"]; ok {
		var downloadInfo []DownloadInfo
		if err := json.Unmarshal(v, &downloadInfo); err == nil {
			track.DownloadInfo = downloadInfo
		}
	}
	if v, ok := raw["position"]; ok {
		var pos TrackPosition
		if err := json.Unmarshal(v, &pos); err == nil {
			track.Position = &pos
		}
	}

	return track, nil
}

// DeList deserializes a list of TrackShort
func (t *TrackShort) DeList(data []byte, c 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 {
		track := &TrackShort{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, track); err != nil {
			continue
		}
		result = append(result, track)
	}
	return result, nil
}

// TracksList represents a list of tracks with metadata
type TracksList struct {
	BaseModel
	Tracks   []TrackShort `json:"tracks"`
	Total    int          `json:"total"`
	Page     int          `json:"page"`
	PageSize int          `json:"page_size"`
	Pager    *Pager       `json:"pager"`
}

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

	list := &TracksList{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["tracks"]; ok {
		var tracks []TrackShort
		if err := json.Unmarshal(v, &tracks); err == nil {
			list.Tracks = tracks
		}
	}
	if v, ok := raw["total"]; ok {
		json.Unmarshal(v, &list.Total)
	}
	if v, ok := raw["page"]; ok {
		json.Unmarshal(v, &list.Page)
	}
	if v, ok := raw["page_size"]; ok {
		json.Unmarshal(v, &list.PageSize)
	}
	if v, ok := raw["pager"]; ok {
		var pager Pager
		if err := json.Unmarshal(v, &pager); err == nil {
			list.Pager = &pager
		}
	}

	return list, nil
}

// DeList deserializes a list of TracksList
func (t *TracksList) DeList(data []byte, c 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 {
		list := &TracksList{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, list); err != nil {
			continue
		}
		result = append(result, list)
	}
	return result, nil
}

// Pager represents pagination info
type Pager struct {
	BaseModel
	Total    int  `json:"total"`
	Page     int  `json:"page"`
	PageSize int  `json:"page_size"`
	Pages    int  `json:"pages"`
	PerPage  int  `json:"per_page"`
	PrevPage *int `json:"prev_page"`
	NextPage *int `json:"next_page"`
	HasPrev  bool `json:"has_prev"`
	HasNext  bool `json:"has_next"`
}

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

	pager := &Pager{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["total"]; ok {
		json.Unmarshal(v, &pager.Total)
	}
	if v, ok := raw["page"]; ok {
		json.Unmarshal(v, &pager.Page)
	}
	if v, ok := raw["page_size"]; ok {
		json.Unmarshal(v, &pager.PageSize)
	}
	if v, ok := raw["pages"]; ok {
		json.Unmarshal(v, &pager.Pages)
	}
	if v, ok := raw["per_page"]; ok {
		json.Unmarshal(v, &pager.PerPage)
	}
	if v, ok := raw["prev_page"]; ok {
		var prev int
		if err := json.Unmarshal(v, &prev); err == nil {
			pager.PrevPage = &prev
		}
	}
	if v, ok := raw["next_page"]; ok {
		var next int
		if err := json.Unmarshal(v, &next); err == nil {
			pager.NextPage = &next
		}
	}
	if v, ok := raw["has_prev"]; ok {
		json.Unmarshal(v, &pager.HasPrev)
	}
	if v, ok := raw["has_next"]; ok {
		json.Unmarshal(v, &pager.HasNext)
	}

	return pager, nil
}

// DeList deserializes a list of Pager
func (p *Pager) DeList(data []byte, c 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 {
		pager := &Pager{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, pager); err != nil {
			continue
		}
		result = append(result, pager)
	}
	return result, nil
}

// TrackPosition represents track position in a playlist/queue
type TrackPosition struct {
	BaseModel
	Revision  int    `json:"revision"`
	Timestamp string `json:"timestamp"`
	Position  int    `json:"position"`
	FromCache bool   `json:"from_cache"`
}

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

	pos := &TrackPosition{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["revision"]; ok {
		json.Unmarshal(v, &pos.Revision)
	}
	if v, ok := raw["timestamp"]; ok {
		json.Unmarshal(v, &pos.Timestamp)
	}
	if v, ok := raw["position"]; ok {
		json.Unmarshal(v, &pos.Position)
	}
	if v, ok := raw["from_cache"]; ok {
		json.Unmarshal(v, &pos.FromCache)
	}

	return pos, nil
}

// DeList deserializes a list of TrackPosition
func (tp *TrackPosition) DeList(data []byte, c 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 {
		pos := &TrackPosition{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, pos); err != nil {
			continue
		}
		result = append(result, pos)
	}
	return result, nil
}