To tap on an artist from the search results and

go to the next page, we have to do two things.

Define a method in the iTunes API client that performs the request for us and

returns a populated artist instance containing the albums and

update the code in the prepare for

Segway method on the search results controller where we're using step data.

So first up, iTunes API client.

And in here, let's add a second method.

And we'll call this one func lookupArtist(withId id: Int),

so here we also need a completion handler.

And this is also going to be an escaping closure.

And the signature here, since we're looking up a single artist and

returning it, is Artist, and so we'll make this optional, or

an ItunesError, also optional, so void.

Most of the body of this method is the same,

we just need to parse the resulting JSON differently.

So again, first we need an endpoint, let endpoint.

At some point, we'll learn how to type out endpoint.

So Itunes.lookup this time.

Pass the id through and the entity is MusicEntity.album.

Like before we can use the endpoint to create and carry out in JSON task.

So let task = downloader.JSONTask with endpoint.request.

And again, we'll use a trailing closure to get the JSON and

error object to work with, remember, do not forget to call task.resume.

Just like the previous method, I'm going to jump back onto the main thread here,

since everything we're doing now is synchronous and

won't block the main thread.

This removes the burden of having to remember to do it at the call sign.

So DispatchQueue.main.async.

Again here, the JSON body is optional and may be new, so

we need to unwrap it and check for an error first.

We can copy-paste this block.

So up at the top, we'll grab this guard let json = json, paste that in here,

and the only thing we need to change, instead of passing an empty array as

the argument to the completion handler, it's nil this time,

because we don't have an array of artists anymore, just a single one.

In this payload of data,

inside this JSON response, we still have a top level dictionary.

And all the information we want is housed under the result key.

So we can actually copy paste this second bit of code as well.

Now, come to think of it, this is also how the third method,

the lookup album method is going to be structured.

So already we're repeating the work, but

instead of repeating this work three times.

Let's factor this out into a single method that we can use.

We'll make this a private method.

We'll say private func, perform request with endpoint.

Hey, look at that, I typed endpoint correctly.

The completion handler here is also going to be escaping.

And the signature will be (Results?,

ItunesError?) -> Void).

Now, what is this results type here?

Well, it's just the type alias for the kind of data we're going to get

using the results key which is an array of dictionaries.

So we'll just create that right above that here.

We'll say type alias results equal and we'll paste that type in.

Now, we can go back to the top here and

let's just copy paste the body of the first method except this endpoint bit.

So let task all the way to resume and paste it in here inside this new method.

We'll change the empty arrays case here in the failure case to nil for

every single one.

We'll get rid of the artist-related code at the bottom and

just call the completion handler with this results object that we're parsing.

Now, we can refactor out our first method

to use this function instead of doing all of that work again.

That way we don't have to call create three JSON tasks, call resume three times,

call dispatchQueue.main.async three times and

then get to the result object three times.

So instead we'll get rid of all of this except the endpoint.

And inside searchForArtists we can say performRequest with endpoint and

the completion handler here is results comma error in.

And now, we need to make sure that we have a results object,

cuz this could be optional.

So we'll say guard let results equal results else.

Here we'll call completion.

And this time, since we're in the search for artists, which calls a closure

that accepts an array of artists, we'll parse an empty array and new and return.

And then at the bottom, we can say, let artists = results.flatMap Artist,

using the json initializer, and we'll parsing the argument.

And then again, we'll call the completion handler and

pass through the artists or nil.

Okay, so we've refactored it out and

we've moved much of the logic that we had in searchForArtists into this new method.

So we can now use it everywhere.

So again back in the second method, I can copy paste this in,

right, so we don't need any of this, get rid of it.

And get rid of this artist stuff at the bottom, so this time, we made a mistake.

So instead of empty array and nil here this is empty array and error.

And then down here this is nil and an error.

And now, so this bit is the same.

So perform request with endpoint and

check the results object, that bit is the same in every case.

And now, we can move on to actually parsing that results and

returning an artist.

In this case, the first object in the results array

is a dictionary containing information about the artist.

So let's get that out and create an artist instance with it.

First we'll make sure the results array isn't empty and we'll do that by calling

the first property to get the dictionary or return an error.

So inside here, we'll say guard let artistInfo =

results.first else { Completion,

so obviously we have an error case, so no artist.

And then the error is .jsonParsingFailure.

And the message we wanna pass through is Results does

not contain artist info and then we'll return.

Once we have this artist info dictionary,

we can use it to create an artist instance.

Again, we need to use a guard statement here since the initializer is fallible.

So we'll say guard let artist equal, we'll used that

JSON initializer, pass in the artistInfo dictionary.

And if this doesn't work, then, again, we'll call the completion handler.

We'll pass nil through for the artist and then, we'll say .jsonParsingFailure and

the message here is Could not parse artist information.

This is an all that different from the data we had when we use the search

endpoint.

The difference in this method is that the results array contains all

the albums pertaining to the artist at index 1 all the way to the end.

So now, let's grab those dictionaries and

create individual album instances out of each of them.

So, let albumResults = results.

That is our array of dictionaries and we'll use subscript notation,

along with a range, to create an array slice, which is a portion of the array.

So remember in the results array for this endpoint,

the first dictionary in there contains information about the artist, but

everything from index 1 to the end is information about the album.

So we'll start at index 1 and we'll go all the way to the end, raising results.count.

And notice this is a half open range.

So we're not going to include this value, which would mean index out of bounds.

So now we have all the album dictionaries and we can create albums out of that

pretty easily by just parsing it with the flatMap function.

So album, we'll use the JSON initializer, and $0.

Again here we're using flatMap to end up with a non-option array of albums.

We can now assign these albums back to the stored property on the artist object and

call the success case of the completion handler.

So artist.albums = albums.

And then completion(artist, nil).

So let's test this out.

Let's head over to the prepare, actually what was that error, let me go back.

I forgot to return, which is always important.

Okay, so in the search results controller,

I want to go to this prepare for Segway method.

After we figure out what artist that use your tabbed on which is right here.

Let's get rid of this stub data and look up the artist using the API client.

So I'll get rid of this and I'll say client.lookup artist with ID.

And this is artist.id.

And the completion handler here returns either an artist or an error,

and inside this closure we'll assign this artist instance containing the albums

to the storic property on the destination controller and reload the table view.

So let's move this code up and here's a little magic trick.

You can hold down command option and then use the opening square bracket to kind of

move it through like that all the way to the top.

And then we're going to move this into

the closure like that and now,

we'll just use the album list controllers table view and call reload data on it.

Now, if we test this out, type an artist name and

select it, you're actually going to crash.

And this is a bit of intentional work on my part

to remind you never to trust force unwrapping.

If you go to the AlbumListController and look at the artist property, this

uses an explicitly unwrapped property, because while we needed it to be variable,

we didn't want to unwrap it all over the place when we created it.

We're crashing because we tried to assign a title to the view controller in here.

Using an object that is nil when the view loads.

Even if you fix this line of code, that wouldn't be good enough

because the data source is also now being initialized with a new variable.

Just because all of this worked in our stubbed code

doesn't mean it'll work the same when we use asynchronous networking code, so

let's make a few changes.

First, we're going to change this artist property to a standard optional.

Next, we're going to get rid of this lazily created data source and

make that a regular variable stored property.

So no closure anymore.

Instead, We'll initialize it with an instance

of AlbumListDataSource and we'll pass in an empty array for the albums.

This means that once we get the data, we'll need to update the data source.

Since the data source object's data is private,

however, we need to go back to this type, and at the bottom,

we need to add a helper method, func update, to update

that underlying data source with a new set of albums, which is an array of album.

We'll say self.albums = album.

Now, when we set the artist property, in prepare for

Segway, we'll want to set the title.

So let's go back there.

So the album was controller.

So when we set this property, we'll want to set the title, update the data source,

and reload the table view.

And we can do all that by using a did-set property observer on the property, itself.

So inside we'll say didSet and we can say self.title

= artist.title, we'll need a question mark.

We can also say dataSource.update(with: artist!.albums) and

then finally tableView.reloadData().

And we'll get rid of all this or rather just this line of code.

All right, so what's going on here.

Nope, this is artist I believe .name.

Now, let's give it a run.

What's going on here?

Where is this error?

Okay, no errors.

We need to change albums on the AlbumListDataSource to now be variable

since we're updating it at some point with new data.

All right, so just like before, we'll launch the search.

We'll type out the artist name.

We get a bunch of results,

we can click it and now you'll see all of their albums, pretty awesome.

We've got the search results page and the album's page sorted, but we still have to

configure the file view controller to display the album and it's songs.

We've done this twice now, so

you should have a good understanding of how to tackle it.

For the last view controller, I want you to handle it.

In the next video, I'm going to walk through the implementation myself, but

please try and not go to that video, until you've tried to figure it out yourself.

So that means writing the networking code,

updating the view controller with the real data, and

then changing any of the data source stuff that you need to get it to work.