import {
	IExecuteFunctions,
} from 'n8n-core';

import {
	IDataObject,
	INodeExecutionData,
	INodeType,
	INodeTypeDescription,
} from 'n8n-workflow';

import {
	spotifyApiRequest,
	spotifyApiRequestAllItems,
} from './GenericFunctions';

import {
	isoCountryCodes
} from './IsoCountryCodes';

export class Spotify implements INodeType {
	description: INodeTypeDescription = {
		displayName: 'Spotify',
		name: 'spotify',
		icon: 'file:spotify.svg',
		group: ['input'],
		version: 1,
		description: 'Access public song data via the Spotify API',
		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
		defaults: {
			name: 'Spotify',
			color: '#1DB954',
		},
		inputs: ['main'],
		outputs: ['main'],
		credentials: [
			{
				name: 'spotifyOAuth2Api',
				required: true,
			},
		],
		properties: [
			// ----------------------------------------------------------------
			//         Resource to Operate on
			//         Album, Artist, Library, My Data, Player, Playlist, Track
			// ----------------------------------------------------------------
			{
				displayName: 'Resource',
				name: 'resource',
				type: 'options',
				options: [
					{
						name: 'Album',
						value: 'album',
					},
					{
						name: 'Artist',
						value: 'artist',
					},
					{
						name: 'Library',
						value: 'library',
					},
					{
						name: 'My Data',
						value: 'myData',
					},
					{
						name: 'Player',
						value: 'player',
					},
					{
						name: 'Playlist',
						value: 'playlist',
					},
					{
						name: 'Track',
						value: 'track',
					},
				],
				default: 'player',
				description: 'The resource to operate on.',
			},

			// --------------------------------------------------------------------------------------------------------
			//         Player Operations
			//         Pause, Play, Resume, Get Recently Played, Get Currently Playing, Next Song, Previous Song,
			//         Add to Queue, Set Volume
			// --------------------------------------------------------------------------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'player',
						],
					},
				},
				options: [
					{
						name: 'Add Song to Queue',
						value: 'addSongToQueue',
						description: 'Add a song to your queue.',
					},
					{
						name: 'Currently Playing',
						value: 'currentlyPlaying',
						description: 'Get your currently playing track.',
					},
					{
						name: 'Next Song',
						value: 'nextSong',
						description: 'Skip to your next track.',
					},
					{
						name: 'Pause',
						value: 'pause',
						description: 'Pause your music.',
					},
					{
						name: 'Previous Song',
						value: 'previousSong',
						description: 'Skip to your previous song.',
					},
					{
						name: 'Recently Played',
						value: 'recentlyPlayed',
						description: 'Get your recently played tracks.',
					},
					{
						name: 'Resume',
						value: 'resume',
						description: 'Resume playback on the current active device.',
					},
					{
						name: 'Set Volume',
						value: 'volume',
						description: 'Set volume on the current active device.',
					},
					{
						name: 'Start Music',
						value: 'startMusic',
						description: 'Start playing a playlist, artist, or album.',
					},
				],
				default: 'addSongToQueue',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Resource ID',
				name: 'id',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'player',
						],
						operation: [
							'startMusic',
						],
					},
				},
				placeholder: 'spotify:album:1YZ3k65Mqw3G8FzYlW1mmp',
				description: `Enter a playlist, artist, or album URI or ID.`,
			},
			{
				displayName: 'Track ID',
				name: 'id',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'player',
						],
						operation: [
							'addSongToQueue',
						],
					},
				},
				placeholder: 'spotify:track:0xE4LEFzSNGsz1F6kvXsHU',
				description: `Enter a track URI or ID.`,
			},

			// -----------------------------------------------
			//         Album Operations
			//         Get an Album, Get an Album's Tracks
			// -----------------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'album',
						],
					},
				},
				options: [
					{
						name: 'Get',
						value: 'get',
						description: 'Get an album by URI or ID.',
					},
					{
						name: 'Get New Releases',
						value: 'getNewReleases',
						description: 'Get a list of new album releases.',
					},
					{
						name: `Get Tracks`,
						value: 'getTracks',
						description: `Get an album's tracks by URI or ID.`,
					},
					{
						name: `Search`,
						value: 'search',
						description: `Search albums by keyword.`,
					},
				],
				default: 'get',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Album ID',
				name: 'id',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'album',
						],
						operation: [
							'get',
							'getTracks',
						],
					},
					hide: {
						operation: [
							'search',
						],
					},
				},
				placeholder: 'spotify:album:1YZ3k65Mqw3G8FzYlW1mmp',
				description: `The album's Spotify URI or ID.`,
			},
			{
				displayName: 'Search Keyword',
				name: 'query',
				type: 'string',
				required: true,
				default: '',
				description: 'The keyword term to search for.',
				displayOptions: {
					show: {
						resource: [
							'album',
						],
						operation: [
							'search',
						],
					},
				},
			},

			// -------------------------------------------------------------------------------------------------------------
			//         Artist Operations
			//         Get an Artist, Get an Artist's Related Artists, Get an Artist's Top Tracks, Get an Artist's Albums
			// -------------------------------------------------------------------------------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'artist',
						],
					},
				},
				options: [
					{
						name: 'Get',
						value: 'get',
						description: 'Get an artist by URI or ID.',
					},
					{
						name: `Get Albums`,
						value: 'getAlbums',
						description: `Get an artist's albums by URI or ID.`,
					},
					{
						name: `Get Related Artists`,
						value: 'getRelatedArtists',
						description: `Get an artist's related artists by URI or ID.`,
					},
					{
						name: `Get Top Tracks`,
						value: 'getTopTracks',
						description: `Get an artist's top tracks by URI or ID.`,
					},
					{
						name: `Search`,
						value: 'search',
						description: `Search artists by keyword.`,
					},
				],
				default: 'get',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Artist ID',
				name: 'id',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'artist',
						],
					},
					hide: {
						operation: [
							'search',
						],
					},
				},
				placeholder: 'spotify:artist:4LLpKhyESsyAXpc4laK94U',
				description: `The artist's Spotify URI or ID.`,
			},
			{
				displayName: 'Country',
				name: 'country',
				type: 'string',
				default: 'US',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'artist',
						],
						operation: [
							'getTopTracks',
						],
					},
				},
				placeholder: 'US',
				description: `Top tracks in which country? Enter the postal abbriviation.`,
			},

			{
				displayName: 'Search Keyword',
				name: 'query',
				type: 'string',
				required: true,
				default: '',
				description: 'The keyword term to search for.',
				displayOptions: {
					show: {
						resource: [
							'artist',
						],
						operation: [
							'search',
						],
					},
				},
			},

			// -------------------------------------------------------------------------------------------------------------
			//         Playlist Operations
			//         Get a Playlist, Get a Playlist's Tracks, Add/Remove a Song from a Playlist, Get a User's Playlists
			// -------------------------------------------------------------------------------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
					},
				},
				options: [
					{
						name: 'Add an Item',
						value: 'add',
						description: 'Add tracks from a playlist by track and playlist URI or ID.',
					},
					{
						name: 'Create a Playlist',
						value: 'create',
						description: 'Create a new playlist.',
					},
					{
						name: 'Get',
						value: 'get',
						description: 'Get a playlist by URI or ID.',
					},
					{
						name: 'Get Tracks',
						value: 'getTracks',
						description: `Get a playlist's tracks by URI or ID.`,
					},
					{
						name: `Get the User's Playlists`,
						value: 'getUserPlaylists',
						description: `Get a user's playlists.`,
					},
					{
						name: 'Remove an Item',
						value: 'delete',
						description: 'Remove tracks from a playlist by track and playlist URI or ID.',
					},
					{
						name: `Search`,
						value: 'search',
						description: `Search playlists by keyword.`,
					},
				],
				default: 'add',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Playlist ID',
				name: 'id',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
						operation: [
							'add',
							'delete',
							'get',
							'getTracks',
						],
					},
				},
				placeholder: 'spotify:playlist:37i9dQZF1DWUhI3iC1khPH',
				description: `The playlist's Spotify URI or its ID.`,
			},
			{
				displayName: 'Name',
				name: 'name',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
						operation: [
							'create',
						],
					},
				},
				placeholder: 'Favorite Songs',
				description: 'Name of the playlist to create.',
			},
			{
				displayName: 'Additional Fields',
				name: 'additionalFields',
				type: 'collection',
				placeholder: 'Add Field',
				default: {},
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
						operation: [
							'create',
						],
					},
				},
				options: [
					{
						displayName: 'Description',
						name: 'description',
						type: 'string',
						default: '',
						placeholder: 'These are all my favorite songs.',
						description: 'Description for the playlist to create.',
					},
					{
						displayName: 'Public',
						name: 'public',
						type: 'boolean',
						default: true,
						description: 'Whether the playlist is publicly accessible.',
					},
				],
			},
			{
				displayName: 'Track ID',
				name: 'trackID',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
						operation: [
							'add',
							'delete',
						],
					},
				},
				placeholder: 'spotify:track:0xE4LEFzSNGsz1F6kvXsHU',
				description: `The track's Spotify URI or its ID. The track to add/delete from the playlist.`,
			},
			{
				displayName: 'Additional Fields',
				name: 'additionalFields',
				type: 'collection',
				placeholder: 'Add Field',
				default: {},
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
						operation: [
							'add',
						],
					},
				},
				options: [
					{
						displayName: 'Position',
						name: 'position',
						type: 'number',
						typeOptions: {
							minValue: 0,
						},
						default: 0,
						placeholder: '0',
						description: `The new track's position in the playlist.`,
					},
				],
			},
			{
				displayName: 'Search Keyword',
				name: 'query',
				type: 'string',
				required: true,
				default: '',
				description: 'The keyword term to search for.',
				displayOptions: {
					show: {
						resource: [
							'playlist',
						],
						operation: [
							'search',
						],
					},
				},
			},

			// -----------------------------------------------------
			//         Track Operations
			//         Get a Track, Get a Track's Audio Features
			// -----------------------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'track',
						],
					},
				},
				options: [
					{
						name: 'Get',
						value: 'get',
						description: 'Get a track by its URI or ID.',
					},
					{
						name: 'Get Audio Features',
						value: 'getAudioFeatures',
						description: 'Get audio features for a track by URI or ID.',
					},
					{
						name: 'Search',
						value: 'search',
						description: `Search tracks by keyword.`,
					},
				],
				default: 'track',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Track ID',
				name: 'id',
				type: 'string',
				default: '',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'track',
						],
					},
					hide: {
						operation: [
							'search',
						],
					},
				},
				placeholder: 'spotify:track:0xE4LEFzSNGsz1F6kvXsHU',
				description: `The track's Spotify URI or ID.`,
			},
			{
				displayName: 'Search Keyword',
				name: 'query',
				type: 'string',
				required: true,
				default: '',
				description: 'The keyword term to search for.',
				displayOptions: {
					show: {
						resource: [
							'track',
						],
						operation: [
							'search',
						],
					},
				},
			},

			// -----------------------------------------------------
			//         Library Operations
			//         Get liked tracks
			// -----------------------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'library',
						],
					},
				},
				options: [
					{
						name: 'Get Liked Tracks',
						value: 'getLikedTracks',
						description: `Get the user's liked tracks.`,
					},
				],
				default: 'getLikedTracks',
			},

			// ---------------------------------------
			//         My Data Operations
			//         Get Followed Artists
			// ---------------------------------------
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				displayOptions: {
					show: {
						resource: [
							'myData',
						],
					},
				},
				options: [
					{
						name: 'Get Following Artists',
						value: 'getFollowingArtists',
						description: 'Get your followed artists.',
					},
				],
				default: 'getFollowingArtists',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Return All',
				name: 'returnAll',
				type: 'boolean',
				default: false,
				required: true,
				displayOptions: {
					show: {
						resource: [
							'album',
							'artist',
							'library',
							'myData',
							'playlist',
							'track',
							'player',
						],
						operation: [
							'getTracks',
							'getAlbums',
							'getUserPlaylists',
							'getNewReleases',
							'getLikedTracks',
							'getFollowingArtists',
							'search',
							'recentlyPlayed',
						],
					},
				},
				description: `The number of items to return.`,
			},
			{
				displayName: 'Limit',
				name: 'limit',
				type: 'number',
				default: 50,
				required: true,
				displayOptions: {
					show: {
						resource: [
							'album',
							'artist',
							'library',
							'playlist',
							'track',
						],
						operation: [
							'getTracks',
							'getAlbums',
							'getUserPlaylists',
							'getNewReleases',
							'getLikedTracks',
							'search',
						],
						returnAll: [
							false,
						],
					},
				},
				typeOptions: {
					minValue: 1,
					maxValue: 100,
				},
				description: `The number of items to return.`,
			},
			{
				displayName: 'Limit',
				name: 'limit',
				type: 'number',
				default: 50,
				required: true,
				displayOptions: {
					show: {
						resource: [
							'myData',
							'player',
						],
						operation: [
							'getFollowingArtists',
							'recentlyPlayed',
						],
						returnAll: [
							false,
						],
					},
				},
				typeOptions: {
					minValue: 1,
					maxValue: 50,
				},
				description: `The number of items to return.`,
			},
			{
				displayName: 'Volume',
				name: 'volumePercent',
				type: 'number',
				default: 50,
				required: true,
				displayOptions: {
					show: {
						resource: [
							'player',
						],
						operation: [
							'volume',
						],
					},
				},
				typeOptions: {
					minValue: 0,
					maxValue: 100,
				},
				description: `The volume percentage to set.`,
			},
			{
				displayName: 'Filters',
				name: 'filters',
				type: 'collection',
				placeholder: 'Add Filter',
				default: {},
				displayOptions: {
					show: {
						resource: [
							'album',
						],
						operation: [
							'getNewReleases',
						],
					},
				},
				options: [
					{
						displayName: 'Country',
						name: 'country',
						type: 'options',
						default: 'US',
						options: isoCountryCodes.map(({ name, alpha2 }) => ({ name, value: alpha2 })),
						description: 'Country to filter new releases by.',
					},
				],
			},
			{
				displayName: 'Filters',
				name: 'filters',
				type: 'collection',
				placeholder: 'Add Filter',
				default: {},
				displayOptions: {
					show: {
						resource: [
							'playlist',
							'artist',
							'track',
							'album',
						],
						operation: [
							'search',
						],
					},
				},
				options: [
					{
						displayName: 'Country',
						name: 'market',
						type: 'options',
						options: isoCountryCodes.map(({ name, alpha2 }) => ({ name, value: alpha2 })),
						default: '',
						description: `If a country code is specified, only content that is playable in that market is returned.`,
					},
				],
			},
		],
	};

	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
		// Get all of the incoming input data to loop through
		const items = this.getInputData();
		const returnData: IDataObject[] = [];

		// For Post
		let body: IDataObject;
		// For Query string
		let qs: IDataObject;

		let requestMethod: string;
		let endpoint: string;
		let returnAll: boolean;
		let propertyName = '';
		let responseData;

		const operation = this.getNodeParameter('operation', 0) as string;
		const resource = this.getNodeParameter('resource', 0) as string;

		// Set initial values
		requestMethod = 'GET';
		endpoint = '';
		body = {};
		qs = {};
		returnAll = false;

		for (let i = 0; i < items.length; i++) {
			try {
				if (resource === 'player') {

					// -----------------------------
					//      Player Operations
					// -----------------------------

					if (operation === 'pause') {
						requestMethod = 'PUT';

						endpoint = `/me/player/pause`;


						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };

					} else if (operation === 'recentlyPlayed') {
						requestMethod = 'GET';

						endpoint = `/me/player/recently-played`;

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						propertyName = 'items';

						if (!returnAll) {

							const limit = this.getNodeParameter('limit', i) as number;

							qs = {
								limit,
							};

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

							responseData = responseData.items;
						}

					} else if (operation === 'currentlyPlaying') {
						requestMethod = 'GET';

						endpoint = `/me/player/currently-playing`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

					} else if (operation === 'nextSong') {
						requestMethod = 'POST';

						endpoint = `/me/player/next`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };

					} else if (operation === 'previousSong') {
						requestMethod = 'POST';

						endpoint = `/me/player/previous`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };

					} else if (operation === 'startMusic') {
						requestMethod = 'PUT';

						endpoint = `/me/player/play`;

						const id = this.getNodeParameter('id', i) as string;

						body.context_uri = id;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };

					} else if (operation === 'addSongToQueue') {
						requestMethod = 'POST';

						endpoint = `/me/player/queue`;

						const id = this.getNodeParameter('id', i) as string;

						qs = {
							uri: id,
						};

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };
					} else if (operation === 'resume') {
						requestMethod = 'PUT';

						endpoint = `/me/player/play`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };
					} else if (operation === 'volume') {
						requestMethod = 'PUT';

						endpoint = `/me/player/volume`;

						const volumePercent = this.getNodeParameter('volumePercent', i) as number;

						qs = {
							volume_percent: volumePercent,
						};

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = { success: true };
					}

				} else if (resource === 'album') {

					// -----------------------------
					//      Album Operations
					// -----------------------------

					if (operation === 'get') {
						const uri = this.getNodeParameter('id', i) as string;

						const id = uri.replace('spotify:album:', '');

						requestMethod = 'GET';

						endpoint = `/albums/${id}`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

					} else if (operation === 'getNewReleases') {

						endpoint = '/browse/new-releases';
						requestMethod = 'GET';

						const filters = this.getNodeParameter('filters', i) as IDataObject;

						if (Object.keys(filters).length) {
							Object.assign(qs, filters);
						}

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						if (!returnAll) {
							qs.limit = this.getNodeParameter('limit', i);
							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
							responseData = responseData.albums.items;
						}

					} else if (operation === 'getTracks') {
						const uri = this.getNodeParameter('id', i) as string;

						const id = uri.replace('spotify:album:', '');

						requestMethod = 'GET';

						endpoint = `/albums/${id}/tracks`;

						propertyName = 'tracks';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						propertyName = 'items';

						if (!returnAll) {
							const limit = this.getNodeParameter('limit', i) as number;

							qs = {
								limit,
							};

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

							responseData = responseData.items;
						}
					} else if (operation === 'search') {
						requestMethod = 'GET';

						endpoint = '/search';

						propertyName = 'albums.items';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;
						const q = this.getNodeParameter('query', i) as string;
						const filters = this.getNodeParameter('filters', i) as IDataObject;

						qs = {
							q,
							type: 'album',
							...filters,
						};

						if (returnAll === false) {
							const limit = this.getNodeParameter('limit', i) as number;
							qs.limit = limit;
							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
							responseData = responseData.albums.items;
						}
					}

				} else if (resource === 'artist') {

					// -----------------------------
					//      Artist Operations
					// -----------------------------

					const uri = this.getNodeParameter('id', i, '') as string;

					const id = uri.replace('spotify:artist:', '');

					if (operation === 'getAlbums') {

						endpoint = `/artists/${id}/albums`;

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						propertyName = 'items';

						if (!returnAll) {
							const limit = this.getNodeParameter('limit', i) as number;

							qs = {
								limit,
							};

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

							responseData = responseData.items;
						}

					} else if (operation === 'getRelatedArtists') {

						endpoint = `/artists/${id}/related-artists`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = responseData.artists;

					} else if (operation === 'getTopTracks') {
						const country = this.getNodeParameter('country', i) as string;

						qs = {
							country,
						};

						endpoint = `/artists/${id}/top-tracks`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						responseData = responseData.tracks;

					} else if (operation === 'get') {

						requestMethod = 'GET';

						endpoint = `/artists/${id}`;

						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
					} else if (operation === 'search') {
						requestMethod = 'GET';

						endpoint = '/search';

						propertyName = 'artists.items';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;
						const q = this.getNodeParameter('query', i) as string;
						const filters = this.getNodeParameter('filters', i) as IDataObject;

						qs = {
							q,
							limit: 50,
							type: 'artist',
							...filters,
						};

						if (returnAll === false) {
							const limit = this.getNodeParameter('limit', i) as number;
							qs.limit = limit;
							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
							responseData = responseData.artists.items;
						}
					}

				} else if (resource === 'playlist') {

					// -----------------------------
					//      Playlist Operations
					// -----------------------------

					if (['delete', 'get', 'getTracks', 'add'].includes(operation)) {
						const uri = this.getNodeParameter('id', i) as string;

						const id = uri.replace('spotify:playlist:', '');

						if (operation === 'delete') {
							requestMethod = 'DELETE';
							const trackId = this.getNodeParameter('trackID', i) as string;

							body.tracks = [
								{
									uri: trackId,
								},
							];

							endpoint = `/playlists/${id}/tracks`;

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

							responseData = { success: true };

						} else if (operation === 'get') {
							requestMethod = 'GET';

							endpoint = `/playlists/${id}`;

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

						} else if (operation === 'getTracks') {
							requestMethod = 'GET';

							endpoint = `/playlists/${id}/tracks`;

							returnAll = this.getNodeParameter('returnAll', i) as boolean;

							propertyName = 'items';

							if (!returnAll) {
								const limit = this.getNodeParameter('limit', i) as number;

								qs = {
									'limit': limit,
								};

								responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

								responseData = responseData.items;
							}
						} else if (operation === 'add') {
							requestMethod = 'POST';

							const trackId = this.getNodeParameter('trackID', i) as string;
							const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;

							qs = {
								uris: trackId,
							};

							if (additionalFields.position !== undefined) {
								qs.position = additionalFields.position;
							}

							endpoint = `/playlists/${id}/tracks`;

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
						}
					} else if (operation === 'getUserPlaylists') {
						requestMethod = 'GET';

						endpoint = '/me/playlists';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						propertyName = 'items';

						if (!returnAll) {
							const limit = this.getNodeParameter('limit', i) as number;

							qs = {
								limit,
							};

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

							responseData = responseData.items;
						}

					} else if (operation === 'create') {

						// https://developer.spotify.com/console/post-playlists/

						body.name = this.getNodeParameter('name', i) as string;

						const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;

						if (Object.keys(additionalFields).length) {
							Object.assign(body, additionalFields);
						}

						responseData = await spotifyApiRequest.call(this, 'POST', '/me/playlists', body, qs);
					} else if (operation === 'search') {
						requestMethod = 'GET';

						endpoint = '/search';

						propertyName = 'playlists.items';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;
						const q = this.getNodeParameter('query', i) as string;
						const filters = this.getNodeParameter('filters', i) as IDataObject;

						qs = {
							q,
							type: 'playlist',
							limit: 50,
							...filters,
						};

						if (returnAll === false) {
							const limit = this.getNodeParameter('limit', i) as number;
							qs.limit = limit;
							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
							responseData = responseData.playlists.items;
						}
					}

				} else if (resource === 'track') {

					// -----------------------------
					//      Track Operations
					// -----------------------------

					const uri = this.getNodeParameter('id', i, '') as string;

					const id = uri.replace('spotify:track:', '');

					requestMethod = 'GET';

					if (operation === 'getAudioFeatures') {
						endpoint = `/audio-features/${id}`;
						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
					} else if (operation === 'get') {
						endpoint = `/tracks/${id}`;
						responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
					} else if (operation === 'search') {
						requestMethod = 'GET';

						endpoint = '/search';

						propertyName = 'tracks.items';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;
						const q = this.getNodeParameter('query', i) as string;
						const filters = this.getNodeParameter('filters', i) as IDataObject;

						qs = {
							q,
							type: 'track',
							limit: 50,
							...filters,
						};

						if (returnAll === false) {
							const limit = this.getNodeParameter('limit', i) as number;
							qs.limit = limit;
							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
							responseData = responseData.tracks.items;
						}
					}

				} else if (resource === 'library') {

					// -----------------------------
					//      Library Operations
					// -----------------------------

					if (operation === 'getLikedTracks') {
						requestMethod = 'GET';

						endpoint = '/me/tracks';

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						propertyName = 'items';

						if (!returnAll) {
							const limit = this.getNodeParameter('limit', i) as number;

							qs = {
								limit,
							};

							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);

							responseData = responseData.items;
						}
					}
				} else if (resource === 'myData') {

					if (operation === 'getFollowingArtists') {
						requestMethod = 'GET';

						endpoint = `/me/following`;

						returnAll = this.getNodeParameter('returnAll', i) as boolean;

						propertyName = 'artists.items';

						qs = {
							type: 'artist',
						};

						if (!returnAll) {
							const limit = this.getNodeParameter('limit', i) as number;
							qs = {
								type: 'artist',
								limit,
							};
							responseData = await spotifyApiRequest.call(this, requestMethod, endpoint, body, qs);
							responseData = responseData.artists.items;
						}
					}
				}

				if (returnAll) {
					responseData = await spotifyApiRequestAllItems.call(this, propertyName, requestMethod, endpoint, body, qs);
				}

				if (Array.isArray(responseData)) {
					returnData.push.apply(returnData, responseData as IDataObject[]);
				} else {
					returnData.push(responseData as IDataObject);
				}
			} catch (error) {
				if (this.continueOnFail()) {
					returnData.push({ error: error.message });
					continue;
				}
				throw error;
			}
		}

		return [this.helpers.returnJsonArray(returnData)];
	}
}