package models

import (
	"encoding/json"
)

// Experiments represents experiments
type Experiments struct {
	BaseModel
	Experiments []ExperimentDetail `json:"experiments"`
	Total       int                `json:"total"`
}

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

	experiments := &Experiments{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["experiments"]; ok {
		var items []ExperimentDetail
		json.Unmarshal(v, &items)
		experiments.Experiments = items
	}
	if v, ok := raw["total"]; ok {
		json.Unmarshal(v, &experiments.Total)
	}

	return experiments, nil
}

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

// ExperimentDetail represents experiment details
type ExperimentDetail struct {
	BaseModel
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
	Status      string `json:"status"`
	Variant     string `json:"variant"`
	StartDate   string `json:"start_date"`
	EndDate     string `json:"end_date"`
}

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

	detail := &ExperimentDetail{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["id"]; ok {
		json.Unmarshal(v, &detail.ID)
	}
	if v, ok := raw["name"]; ok {
		json.Unmarshal(v, &detail.Name)
	}
	if v, ok := raw["description"]; ok {
		json.Unmarshal(v, &detail.Description)
	}
	if v, ok := raw["status"]; ok {
		json.Unmarshal(v, &detail.Status)
	}
	if v, ok := raw["variant"]; ok {
		json.Unmarshal(v, &detail.Variant)
	}
	if v, ok := raw["start_date"]; ok {
		json.Unmarshal(v, &detail.StartDate)
	}
	if v, ok := raw["end_date"]; ok {
		json.Unmarshal(v, &detail.EndDate)
	}

	return detail, nil
}

// DeList deserializes a list of ExperimentDetails
func (e *ExperimentDetail) 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 {
		detail := &ExperimentDetail{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, detail); err != nil {
			continue
		}
		result = append(result, detail)
	}
	return result, nil
}

// Permissions represents user permissions
type Permissions struct {
	BaseModel
	CanPlay           bool `json:"can_play"`
	CanDownload       bool `json:"can_download"`
	CanLike           bool `json:"can_like"`
	CanCreatePlaylist bool `json:"can_create_playlist"`
	CanSubscribe      bool `json:"can_subscribe"`
	CanUsePlus        bool `json:"can_use_plus"`
	CanUseRadio       bool `json:"can_use_radio"`
	CanUseYnison      bool `json:"can_use_ynison"`
	CanUseHighQuality bool `json:"can_use_high_quality"`
	CanUseLossless    bool `json:"can_use_lossless"`
}

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

	perms := &Permissions{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["can_play"]; ok {
		json.Unmarshal(v, &perms.CanPlay)
	}
	if v, ok := raw["can_download"]; ok {
		json.Unmarshal(v, &perms.CanDownload)
	}
	if v, ok := raw["can_like"]; ok {
		json.Unmarshal(v, &perms.CanLike)
	}
	if v, ok := raw["can_create_playlist"]; ok {
		json.Unmarshal(v, &perms.CanCreatePlaylist)
	}
	if v, ok := raw["can_subscribe"]; ok {
		json.Unmarshal(v, &perms.CanSubscribe)
	}
	if v, ok := raw["can_use_plus"]; ok {
		json.Unmarshal(v, &perms.CanUsePlus)
	}
	if v, ok := raw["can_use_radio"]; ok {
		json.Unmarshal(v, &perms.CanUseRadio)
	}
	if v, ok := raw["can_use_ynison"]; ok {
		json.Unmarshal(v, &perms.CanUseYnison)
	}
	if v, ok := raw["can_use_high_quality"]; ok {
		json.Unmarshal(v, &perms.CanUseHighQuality)
	}
	if v, ok := raw["can_use_lossless"]; ok {
		json.Unmarshal(v, &perms.CanUseLossless)
	}

	return perms, nil
}

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

// PermissionAlerts represents permission alerts
type PermissionAlerts struct {
	BaseModel
	Alerts []PermissionAlert `json:"alerts"`
	Total  int               `json:"total"`
}

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

	alerts := &PermissionAlerts{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["alerts"]; ok {
		var items []PermissionAlert
		json.Unmarshal(v, &items)
		alerts.Alerts = items
	}
	if v, ok := raw["total"]; ok {
		json.Unmarshal(v, &alerts.Total)
	}

	return alerts, nil
}

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

// PermissionAlert represents a permission alert
type PermissionAlert struct {
	BaseModel
	ID          string `json:"id"`
	Type        string `json:"type"`
	Title       string `json:"title"`
	Description string `json:"description"`
	Action      string `json:"action"`
	IsRead      bool   `json:"is_read"`
	CreatedAt   string `json:"created_at"`
}

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

	alert := &PermissionAlert{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["id"]; ok {
		json.Unmarshal(v, &alert.ID)
	}
	if v, ok := raw["type"]; ok {
		json.Unmarshal(v, &alert.Type)
	}
	if v, ok := raw["title"]; ok {
		json.Unmarshal(v, &alert.Title)
	}
	if v, ok := raw["description"]; ok {
		json.Unmarshal(v, &alert.Description)
	}
	if v, ok := raw["action"]; ok {
		json.Unmarshal(v, &alert.Action)
	}
	if v, ok := raw["is_read"]; ok {
		json.Unmarshal(v, &alert.IsRead)
	}
	if v, ok := raw["created_at"]; ok {
		json.Unmarshal(v, &alert.CreatedAt)
	}

	return alert, nil
}

// DeList deserializes a list of PermissionAlerts
func (p *PermissionAlert) 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 {
		alert := &PermissionAlert{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, alert); err != nil {
			continue
		}
		result = append(result, alert)
	}
	return result, nil
}

// ContentRestrictions represents content restrictions
type ContentRestrictions struct {
	BaseModel
	HasExplicitContent bool     `json:"has_explicit_content"`
	RestrictedRegions  []string `json:"restricted_regions"`
	AgeRating          int      `json:"age_rating"`
	BlockedTracks      []string `json:"blocked_tracks"`
	BlockedAlbums      []string `json:"blocked_albums"`
	BlockedArtists     []string `json:"blocked_artists"`
}

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

	restrictions := &ContentRestrictions{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["has_explicit_content"]; ok {
		json.Unmarshal(v, &restrictions.HasExplicitContent)
	}
	if v, ok := raw["restricted_regions"]; ok {
		json.Unmarshal(v, &restrictions.RestrictedRegions)
	}
	if v, ok := raw["age_rating"]; ok {
		json.Unmarshal(v, &restrictions.AgeRating)
	}
	if v, ok := raw["blocked_tracks"]; ok {
		json.Unmarshal(v, &restrictions.BlockedTracks)
	}
	if v, ok := raw["blocked_albums"]; ok {
		json.Unmarshal(v, &restrictions.BlockedAlbums)
	}
	if v, ok := raw["blocked_artists"]; ok {
		json.Unmarshal(v, &restrictions.BlockedArtists)
	}

	return restrictions, nil
}

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