Since we have a wrapper type now, the weather model that encapsulates all

of our data, let's modify our method a bit in the DarkSkyAPIClient.

Rename it to start, and you can command click on the method name, and

select Rename.

And we're going to call this getWeather instead, and

we're going to make it private.

In addition, let's right up above it, let's create another type alias.

We'll call this, WeatherCompletionHandler.

The type for this is a closure that accepts an optional weather instance,

an optional DarkSkyError instance, and returns Void.

In our method now named getWeather, we can change this completion handler from

CurrentWeatherCompletionHandler to the new one that defines a weather instance.

Okay, so now we're back in our starting point,

let's define the body of disclosure here in the jsonTask method.

So that once the task is done, it has some code to execute.

Because our JSON can be nil, we're first going to check by

unwrapping it using a guard statement, say guard let json = json.

Now if the JSON is nil, we're going to step into the else clause, and

in here we'll check for an error.

Because we defined the body of the closure in the data task method,

we know that this closure can never be called with both the arguments set to nil.

So if our JSON is nil here, then we absolutely do have an error.

Since the error argument for the completion handler of getWeather is

also optional and of the same type, we can just funnel this through.

So let's say, completion mil for the weather model instance,

and error, from the error right here that we can pass through.

And then as a guard statement, so select and we'll add a return so

that we exit the current scope.

Now back in the current scope, we know we have a valid JSON object, so

the rest is fairly straightforward.

Since we wrote and in it method on whether to create and

instance from JSON, all we have to do is call it.

Again, we'll use a guard statement, attempt to create an instance of whether.

We don't necessarily need to do this, the second bit,

since whether is initializer is fillable, we'll get an optional back.

But because the argument type in the completion handler also has an optional

weather instance, we could simply call it and provide the result nil or not.

The issue in doing that is that if weather is nil,

we don't provide an error at the call site.

So now we do have a case at our final call site where both the model instance and

the error value are nil, which is useless.

So we'll say, guard let weather = Weather,

we use the initializer that accepts json, and we'll pass that through.

For the else clause of this guard statement,

we need to indicate that we failed at parsing the JSON correctly.

Which is just a matter of calling the completion handler providing nil for

the model instance, and indicating that the air is a jsonParsingFailure.

Mean double check that I call that correctly, DarkSkyError,

yeah, jsonParsingFailure.

Okay, and then we'll add a return statement to exit the current scope, and

this is completion, here we go.

Okay, so back at the main scope, we've arrived at our final bit of logic.

We have a valid model instance, so let's call the completion handler again and

pass that as an argument.

Completion handler, weather and nil, and that is it for the body of this closure.

We have now defined what we want to do with the resulting json or error.

Remember that we aren't actually executing anything here,

and no networking call will be made.

And that's because we need to still call resume on the task,

which will do at the bottom, task.resume.

If we call this method, we have an instance of weather to work with

at the end, not current weather which is what we want.

In any case,

since we made this method private, we can call it from our view controller.

To account for that, let's add another method here below it, we'll call this one,

get current weather.

So will say func getCurrentWeather, since that's what we wanted the end.

And the method signature here is the one we defined earlier, that

takes the coordinates and a closure of type current weather completion handler.

So getCurrentWeather at coordinate, of type Coordinate, and

then completionHandler with the local name of completion.

This is an escaping enclosure, And the type is CurrentWeatherCompletionHandler.

Inside the body of the method, we can just call our getWeather method,

this takes a Coordinate, we'll just pass it through.

And then for the completionHandler, we actually do need to provide a body that

defines what we want to do with the potential weather instance or

error object.

So here we'll say, weather error in, we're not gonna do much here.

We'll just call the completion handler, again.

And for the model instance, we'll say weather, and this is optional, so

we'll chain an optional call and say currently or error.

And that wraps things up.

Now you might still be confused, but stay with me.

When we call this method, we're going to recap how all of this works.

In the next video, let's put this networking stack to good use and

clean up the view controller.