001package org.intellimate.izou.sdk.frameworks.music.player;
002
003import org.intellimate.izou.events.EventModel;
004import org.intellimate.izou.identification.IdentificationManager;
005import org.intellimate.izou.resource.ResourceModel;
006import org.intellimate.izou.sdk.frameworks.music.resources.*;
007import org.intellimate.izou.sdk.frameworks.permanentSoundOutput.output.PermanentSoundResources;
008
009import java.util.ArrayList;
010import java.util.List;
011import java.util.Optional;
012
013/**
014 * this interface is used to generate the resources.
015 * @author LeanderK
016 * @version 1.0
017 */
018public interface MusicResourceGenerator extends PermanentSoundResources, MusicProvider, MusicHelper {
019    String PROVIDE_RESOURCE_ERROR = "Error while trying to provide resource: ";
020    String PROVIDE_RESOURCE_ERROR_NOT_CAPABLE = PROVIDE_RESOURCE_ERROR + " not Capable to generate ";
021    String PROVIDE_RESOURCE_ERROR_GENERATING = PROVIDE_RESOURCE_ERROR + " an Error occurred while trying to generate ";
022
023    @Override
024    default List<? extends ResourceModel> announceResources() {
025        List<ResourceModel> list = new ArrayList<>();
026        IdentificationManager.getInstance().getIdentification(this)
027                .ifPresent(id -> {
028                    list.add(new CapabilitiesResource(id));
029                    list.add(new NowPlayingResource(id));
030                    list.add(new ProgressResource(id));
031                    list.add(new TrackInfoResource(id));
032                    list.add(new VolumeResource(id));
033                    list.add(new PlaybackStateResource(id));
034                });
035        list.addAll(PermanentSoundResources.super.announceResources());
036        return list;
037    }
038
039    /**
040     * generates the resources
041     *
042     * @param resourceModel the resourceModel
043     * @param event         the Event
044     * @return a Stream containing the resourceModel(s)
045     */
046    @Override
047    default Optional<? extends ResourceModel> generateResource(ResourceModel resourceModel, Optional<EventModel> event) {
048        switch (resourceModel.getResourceID()) {
049            case PlaybackStateResource.ID: return createPlaybackStateResource();
050            case CapabilitiesResource.RESOURCE_ID : return createCapabilitiesResource();
051            case NowPlayingResource.ID: return createNowPlayingResource();
052            case PlayerResource.RESOURCE_ID : return createPlayerResource();
053            case ProgressResource.ID : return createProgressResource();
054            case TrackInfoResource.RESOURCE_ID: return createTrackInfoResource();
055            case VolumeResource.ID: return createVolumeResource();
056            default: return PermanentSoundResources.super.generateResource(resourceModel, event);
057        }
058    }
059
060    /**
061     * generates the PlaybackState Resource
062     * @return the Resource
063     */
064    default Optional<? extends ResourceModel> createPlaybackStateResource() {
065        if (getPlaybackState() == null) {
066            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "PlaybackState: returned null");
067            return Optional.empty();
068        }
069        Optional<PlaybackStateResource> playbackStateResource = IdentificationManager.getInstance()
070                .getIdentification(this)
071                .map(id -> new PlaybackStateResource(id, getPlaybackState()));
072        if (!playbackStateResource.isPresent()) {
073            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "PlaybackStateResource");
074        }
075        return playbackStateResource;
076    }
077
078    /**
079     * generates the VolumeResource
080     * @return the Resource
081     */
082    default Optional<? extends ResourceModel> createVolumeResource() {
083        if (getVolume() == null) {
084            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "VolumeResource: returned null");
085            return Optional.empty();
086        }
087        Optional<VolumeResource> playerResource = IdentificationManager.getInstance()
088                .getIdentification(this)
089                .map(id -> new VolumeResource(id, getVolume()));
090        if (!playerResource.isPresent()) {
091            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "VolumeResource");
092        }
093        return playerResource;
094    }
095
096    /**
097     * generates the ProgressResource
098     * @return the Resource
099     */
100    default Optional<? extends ResourceModel> createTrackInfoResource() {
101        if (!getCapabilities().providesTrackInfo()) {
102            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_NOT_CAPABLE + "TrackInfo");
103            return Optional.empty();
104        } else if (getCurrentPlaylist() == null || getCurrentPlaylist().getCurrent() == null) {
105            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "TrackInfo: returned null");
106            return Optional.empty();
107        } else {
108            Optional<TrackInfoResource> nowPlayingResource = IdentificationManager.getInstance()
109                    .getIdentification(this)
110                    .map(id -> new TrackInfoResource(id, getCurrentPlaylist().getCurrent()));
111            if (!nowPlayingResource.isPresent()) {
112                getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "TrackInfo");
113            }
114            return nowPlayingResource;
115        }
116    }
117
118    /**
119     * generates the ProgressResource
120     * @return the Resource
121     */
122    default Optional<? extends ResourceModel> createProgressResource() {
123        if (!getCapabilities().providesTrackInfo()) {
124            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_NOT_CAPABLE + "ProgressResource");
125            return Optional.empty();
126        } else if (getCurrentProgress() == null) {
127            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "ProgressResource: returned null");
128            return Optional.empty();
129        } else {
130            Optional<ProgressResource> nowPlayingResource = IdentificationManager.getInstance()
131                    .getIdentification(this)
132                    .map(id -> new ProgressResource(id, getCurrentProgress()));
133            if (!nowPlayingResource.isPresent()) {
134                getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "ProgressResource");
135            }
136            return nowPlayingResource;
137        }
138    }
139
140    /**
141     * generates the PlayerResource
142     * @return the Resource
143     */
144    default Optional<? extends ResourceModel> createPlayerResource() {
145        Optional<PlayerResource> playerResource = IdentificationManager.getInstance()
146                .getIdentification(this)
147                .map(PlayerResource::new);
148        if (!playerResource.isPresent()) {
149            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "PlayerResource");
150        }
151        return playerResource;
152    }
153
154    /**
155     * generates NowPlayingResource
156     * @return the Resource
157     */
158    default Optional<? extends ResourceModel> createNowPlayingResource() {
159        if (!getCapabilities().providesTrackInfo()) {
160            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_NOT_CAPABLE + "NowPlayingResource");
161            return Optional.empty();
162        } else if (getCurrentPlaylist() == null) {
163            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "NowPlayingResource: returned null");
164            return Optional.empty();
165        } else {
166            Optional<NowPlayingResource> nowPlayingResource = IdentificationManager.getInstance()
167                    .getIdentification(this)
168                    .map(id -> new NowPlayingResource(id, getCurrentPlaylist()));
169            if (!nowPlayingResource.isPresent()) {
170                getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "NowPlayingResource");
171            }
172            return nowPlayingResource;
173        }
174    }
175
176    /**
177     * creates the CapabilitiesResource
178     * @return an optional which should contain the CapabilitiesResource
179     */
180    default Optional<? extends ResourceModel> createCapabilitiesResource() {
181        if (getCurrentPlaylist() == null) {
182            getContext().getLogger().error(PROVIDE_RESOURCE_ERROR_GENERATING + "Capabilities: returned null");
183            return Optional.empty();
184        }
185        return IdentificationManager.getInstance().getIdentification(this)
186                .map(id -> new CapabilitiesResource(id, getCapabilities()));
187    }
188}