// Package models provides data models for the Yandex Music API.
package models

import (
	"encoding/json"
)

// Landing represents a landing page from the Yandex Music API.
type Landing struct {
	BaseModel
	ID          JSONID `json:"id"`
	Title       string         `json:"title"`
	Description string         `json:"description"`
	CoverURI    string         `json:"cover_uri"`
	Type        string         `json:"type"`
	Blocks      []LandingBlock `json:"blocks"`
	Available   bool           `json:"available"`
	Pumpkin     bool           `json:"pumpkin"`
	ContentID   string         `json:"content_id"`
}

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

	landing := &Landing{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["id"]; ok {
		json.Unmarshal(v, &landing.ID)
	}
	if v, ok := raw["title"]; ok {
		json.Unmarshal(v, &landing.Title)
	}
	if v, ok := raw["description"]; ok {
		json.Unmarshal(v, &landing.Description)
	}
	if v, ok := raw["cover_uri"]; ok {
		json.Unmarshal(v, &landing.CoverURI)
	}
	if v, ok := raw["type"]; ok {
		json.Unmarshal(v, &landing.Type)
	}
	if v, ok := raw["available"]; ok {
		json.Unmarshal(v, &landing.Available)
	}
	if v, ok := raw["pumpkin"]; ok {
		json.Unmarshal(v, &landing.Pumpkin)
	}
	if v, ok := raw["content_id"]; ok {
		json.Unmarshal(v, &landing.ContentID)
	}

	if v, ok := raw["blocks"]; ok {
		var blocks []LandingBlock
		json.Unmarshal(v, &blocks)
		landing.Blocks = blocks
	}

	return landing, nil
}

// DeList deserializes a list of Landings from JSON data.
func (l *Landing) 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 {
		landing := &Landing{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, landing); err != nil {
			continue
		}
		result = append(result, landing)
	}
	return result, nil
}

// LandingBlock represents a block in a landing.
type LandingBlock struct {
	BaseModel
	ID JSONID `json:"id"`
	Type        string            `json:"type"`
	Title       string            `json:"title"`
	Description string            `json:"description"`
	Data        *LandingBlockData `json:"data"`
}

// LandingBlockData represents data in a landing block.
type LandingBlockData struct {
	Tracks            []Track            `json:"tracks"`
	Playlists         []Playlist         `json:"playlists"`
	Albums            []Album            `json:"albums"`
	Artists           []Artist           `json:"artists"`
	GeneratedPlaylist *GeneratedPlaylist `json:"generated_playlist"`
}

// LandingList represents a list of landings.
type LandingList struct {
	BaseModel
	Type           string         `json:"type"`
	TypeForFrom    string         `json:"type_for_from"`
	Title          string         `json:"title"`
	ID             string         `json:"id"`
	Landings       []Landing      `json:"landings"`
	NewReleases    []int          `json:"new_releases"`
	NewPlaylists   []PlaylistID   `json:"new_playlists"`
	Podcasts       []int          `json:"podcasts"`
	Total          int            `json:"total"`
	Page           int            `json:"page"`
	PageSize       int            `json:"page_size"`
}

// PlaylistID represents a playlist ID reference.
type PlaylistID struct {
	BaseModel
	UID     int    `json:"uid"`
	Kind    int    `json:"kind"`
}

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

	playlistID := &PlaylistID{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["uid"]; ok {
		json.Unmarshal(v, &playlistID.UID)
	}
	if v, ok := raw["kind"]; ok {
		json.Unmarshal(v, &playlistID.Kind)
	}

	return playlistID, nil
}

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

// DeJSON deserializes a LandingList from JSON data.
func (ll *LandingList) 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 := &LandingList{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["landings"]; ok {
		var landings []Landing
		json.Unmarshal(v, &landings)
		list.Landings = landings
	}
	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)
	}

	return list, nil
}

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