package com.orchard.models;

import java.util.List;
import java.util.stream.Collectors;
import org.apache.kafka.connect.data.Schema;
import org.apache.kafka.connect.data.SchemaBuilder;
import org.apache.kafka.connect.data.Struct;

public class GlobalSoundRecordingsStreams implements OrchardModel {
    public String globalSoundRecordingUuid;

    public String isrc;

    public String name;

    public String releaseDate;

    public String imageUrl;

    public long popularity;

    public String imprint;

    public String types;

    public boolean hasPublicData;

    public String createdAt;

    public String lastModifiedAt;

    public GSSocialAccountIds socialAccountIds;

    public List<GSLabelParticipant> labelParticipants;

    public List<GlobalParticipant> globalParticipants;

    public List<LabelSoundRecording> labelSoundRecordings;

    public static final Schema KafkaSchema = SchemaBuilder.struct().optional()
            .field("globalSoundRecordingUuid", Schema.OPTIONAL_STRING_SCHEMA)
            .field("isrc", Schema.OPTIONAL_STRING_SCHEMA)
            .field("name", Schema.OPTIONAL_STRING_SCHEMA)
            .field("releaseDate", Schema.OPTIONAL_STRING_SCHEMA)
            .field("imageUrl", Schema.OPTIONAL_STRING_SCHEMA)
            .field("popularity", Schema.OPTIONAL_INT64_SCHEMA)
            .field("imprint", Schema.OPTIONAL_STRING_SCHEMA)
            .field("types", Schema.OPTIONAL_STRING_SCHEMA)
            .field("hasPublicData", Schema.OPTIONAL_BOOLEAN_SCHEMA)
            .field("createdAt", Schema.OPTIONAL_STRING_SCHEMA)
            .field("lastModifiedAt", Schema.OPTIONAL_STRING_SCHEMA)
            .field("socialAccountIds", com.orchard.models.GSSocialAccountIds.KafkaSchema)
            .field("globalParticipants",  SchemaBuilder.
                array(GlobalParticipant.KafkaSchema).optional()
                .build())
            .field("labelParticipants",  SchemaBuilder.
                    array(GSLabelParticipant.KafkaSchema).optional()
                    .build())
            .field("labelSoundRecordings",  SchemaBuilder.
                    array(LabelSoundRecording.KafkaSchema).optional()
                    .build())
            .build();

    public Struct ToKafkaStruct() {
        return new Struct(KafkaSchema)
                .put("globalSoundRecordingUuid", globalSoundRecordingUuid)
                .put("isrc", isrc)
                .put("name", name)
                .put("releaseDate", releaseDate)
                .put("imageUrl", imageUrl)
                .put("popularity", popularity)
                .put("imprint", imprint)
                .put("types", types)
                .put("hasPublicData", hasPublicData)
                .put("createdAt", createdAt)
                .put("lastModifiedAt", lastModifiedAt)
                .put("socialAccountIds", socialAccountIds.ToKafkaStruct())
                .put("globalParticipants",
                        globalParticipants.stream()
                                .map(gp -> gp.ToKafkaStruct()).collect(Collectors.toList()))
                .put("labelParticipants",
                        labelParticipants.stream()
                                .map(lp -> lp.ToKafkaStruct()).collect(Collectors.toList()))
                .put("labelSoundRecordings",
                        labelSoundRecordings.stream()
                                .map(ls -> ls.ToKafkaStruct()).collect(Collectors.toList()));
    }
}