#### Collect NCL values for dewtemp_trh from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

dewtemp_data = gdf.get('applications_files/ncl_outputs/dewtemp_trh_output.txt')
dewtemp_data = np.loadtxt(dewtemp_data, delimiter=',', skiprows=6)

### Collect NCL `dewtemp` value and associated (temperature_kelvin, relative humidity) values
ncl_dewtemp = {}
tk_rh = tuple(map(tuple, dewtemp_data[::, 0:2]))
dewtemp_values = dewtemp_data[::, 2]
ncl_dewtemp = dict(zip(tk_rh, dewtemp_values))

### Collect Temperature (Kelvin) and Relative Humidity Pairs
tk_rh = []
for tk in range(273, 374 + 1):
    for rh in range(1, 100 + 1):
        tk_rh.append((tk, rh))

### Calculate GeoCAT-Comp `dewtemp` value and tk/rh
from geocat.comp import dewtemp

geocat_dewtemp = {}

for i, pair in enumerate(tk_rh):
    tk, rh = pair
    geocat_dewtemp[pair] = dewtemp(tk, rh) - 273.15

#### Collect NCL values for daylight_fao56 from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

daylight_data = gdf.get('applications_files/ncl_outputs/daylight_fao56_output.txt')
daylight_data = np.loadtxt(daylight_data, delimiter=',', skiprows=6)

### Collect NCL `daylight_fao56` value and associated (doy, latitude) values
ncl_daylight = {}
doy_lat = tuple(map(tuple, daylight_data[::, 0:2]))
daylight_values = daylight_data[::, 2]
ncl_daylight = dict(zip(doy_lat, daylight_values))

### Collect DOY and Latitude Pairs
doy_lat = []
for doy in range(0, 365 + 1):
    for lat in range(-66, 66 + 1):
        doy_lat.append((doy, lat))

### Calculate GeoCAT-Comp `daylight_fao56` value and doy/lat
from geocat.comp import max_daylight

geocat_daylight = {}

for i, pair in enumerate(doy_lat):
    doy, lat = pair
    geocat_daylight[pair] = max_daylight(doy, lat)

#### Collect NCL values for satvpr_temp_fao56 from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

satvpr_temp_fao56_data = gdf.get(
    'applications_files/ncl_outputs/satvpr_temp_fao56_output.txt'
)
satvpr_temp_fao56_data = np.loadtxt(satvpr_temp_fao56_data, delimiter=',', skiprows=6)

### Collect NCL `satvpr_temp_fao56` value and associated (temp, satvpr_temp) values
ncl_satvpr_temp_fao56 = dict(
    zip(satvpr_temp_fao56_data[::, 0], satvpr_temp_fao56_data[::, 1])
)

### Calculate GeoCAT-Comp `saturation_vapor_pressure`
from geocat.comp import saturation_vapor_pressure

geocat_satvpr_temp_fao56 = {}

for temp in range(33, 212 + 1):
    geocat_satvpr_temp_fao56[temp] = saturation_vapor_pressure(temp)

#### Collect NCL values for satvpr_tdew_fao56 from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

satvpr_tdew_fao56_data = gdf.get(
    'applications_files/ncl_outputs/satvpr_tdew_fao56_output.txt'
)
satvpr_tdew_fao56_data = np.loadtxt(satvpr_tdew_fao56_data, delimiter=',', skiprows=6)

### Collect NCL `satvpr_tdew_fao56` value and associated (temp, act_sat_vapr_pressure) values
ncl_satvpr_tdew_fao56 = dict(
    zip(satvpr_tdew_fao56_data[::, 0], satvpr_tdew_fao56_data[::, 1])
)

### Calculate GeoCAT-Comp `actual_saturation_vapor_pressure`
from geocat.comp import actual_saturation_vapor_pressure

geocat_satvpr_tdew_fao56 = {}

for temp in range(33, 212 + 1):
    geocat_satvpr_tdew_fao56[temp] = actual_saturation_vapor_pressure(temp)

#### Collect NCL values for satvpr_slope_fao56 from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

satvpr_slope_fao56_data = gdf.get(
    'applications_files/ncl_outputs/satvpr_slope_fao56_output.txt'
)
satvpr_slope_fao56_data = np.loadtxt(satvpr_slope_fao56_data, delimiter=',', skiprows=6)

### Collect NCL `satvpr_slope_fao56` value and associated (temp, slope_satvpr) values
ncl_satvpr_slope_fao56 = dict(
    zip(satvpr_slope_fao56_data[::, 0], satvpr_slope_fao56_data[::, 1])
)

### Calculate GeoCAT-Comp `saturation_vapor_pressure_slope`
from geocat.comp import saturation_vapor_pressure_slope

geocat_satvpr_slope_fao56 = {}

for temp in range(33, 212 + 1):
    geocat_satvpr_slope_fao56[temp] = saturation_vapor_pressure_slope(temp)

#### Collect NCL values for coriolis_param from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

coriolis_param_data = gdf.get(
    'applications_files/ncl_outputs/coriolis_param_output.txt'
)
coriolis_param_data = np.loadtxt(coriolis_param_data, delimiter=',', skiprows=6)

### Collect NCL `coriolis_param_data` value and associated coriolis parameter values
ncl_coriolis_param = dict(zip(coriolis_param_data[::, 0], coriolis_param_data[::, 1]))

### Calculate MetPy "coriolis_parameter"
from metpy.calc import coriolis_parameter
from metpy.units import units

metpy_coriolis_para = {}

for lat in range(-90, 90 + 1):
    metpy_coriolis_para[lat] = coriolis_parameter(lat * units.degree).magnitude

#### Collect NCL values for relhum from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

relhum_data = gdf.get('applications_files/ncl_outputs/relhum_output.txt')
relhum_data = np.loadtxt(relhum_data, delimiter=',', skiprows=6)

### Collect NCL `relhum` value and associated (temp, mixing ratio) values
ncl_relhum = {}
temp_mr_press = tuple(map(tuple, relhum_data[::, 0:3]))
relhum_values = relhum_data[::, 3]
ncl_relhum = dict(zip(temp_mr_press, relhum_values))

### Collect Temperature, Mixing Ratio, Pressure
temp_mr_press = []
for temp in range(273, 374 + 1):
    for mr in range(1, 100 + 1):
        for press in range(10000, 15000 + 1, 500):
            temp_mr_press.append((temp, mr, press))

### Calculate GeoCAT-Comp `relhum` value and temp/mixing ratio/pressure
from geocat.comp import relhum

geocat_relhum = {}

for i, variables in enumerate(temp_mr_press):
    temp, mr, press = variables
    geocat_relhum[variables] = relhum(temp, mr, press)

#### Collect NCL values for relhum from geocat-datafiles
import geocat.datafiles as gdf
import numpy as np

relhum_ice_data = gdf.get('applications_files/ncl_outputs/relhum_ice_output.txt')
relhum_ice_data = np.loadtxt(relhum_ice_data, delimiter=',', skiprows=6)

### Collect NCL `relhum_ice` value and associated (temp, mixing ratio) values
ncl_relhum_ice = {}
temp_mr_press = tuple(map(tuple, relhum_ice_data[::, 0:3]))
relhum_ice_values = relhum_ice_data[::, 3]
ncl_relhum_ice = dict(zip(temp_mr_press, relhum_ice_values))

### Collect Temperature, Mixing Ratio, Pressure
temp_mr_press = []
for temp in range(173, 273 + 1):
    for mr in range(1, 100 + 1):
        for press in range(10000, 15000 + 1, 500):
            temp_mr_press.append((temp, mr, press))

### Calculate GeoCAT-Comp `relhum_ice` value and temp/mixing ratio/pressure
from geocat.comp import relhum_ice

geocat_relhum_ice = {}

for i, variables in enumerate(temp_mr_press):
    temp, mr, press = variables
    geocat_relhum_ice[variables] = relhum_ice(temp, mr, press)

import math

for pair in ncl_dewtemp.keys():
    try:
        assert math.isclose(
            ncl_dewtemp[pair], geocat_dewtemp[pair], rel_tol=1e-04
        )  # within 4 decimal points
    except Exception:
        assert math.isclose(
            ncl_dewtemp[pair], geocat_dewtemp[pair], rel_tol=1e-02
        )  # within 2 decimal points
        print(f"{pair}:")
        print(f"\t{ncl_dewtemp[pair]}, {geocat_dewtemp[pair]}")
        print(f"\tDifference: {ncl_dewtemp[pair] - geocat_dewtemp[pair]}")

import math

for pair in ncl_daylight.keys():
    assert math.isclose(
        ncl_daylight[pair], geocat_daylight[pair].flatten()[0], rel_tol=1e-05
    )  # within 5 decimal points

import math

for key in ncl_satvpr_temp_fao56.keys():
    assert math.isclose(
        ncl_satvpr_temp_fao56[key], geocat_satvpr_temp_fao56[key], rel_tol=1e-05
    )  # within 5 decimal points

import math

for key in ncl_satvpr_tdew_fao56.keys():
    assert math.isclose(
        ncl_satvpr_tdew_fao56[key], geocat_satvpr_tdew_fao56[key], rel_tol=1e-05
    )  # within 5 decimal points

import math

for key in ncl_satvpr_slope_fao56.keys():
    assert math.isclose(
        ncl_satvpr_slope_fao56[key], geocat_satvpr_slope_fao56[key], rel_tol=1e-05
    )  # within 5 decimal points

import math

for key in ncl_coriolis_param.keys():
    assert math.isclose(
        ncl_coriolis_param[key], metpy_coriolis_para[key], rel_tol=1e-04
    )  # within 4 decimal points

import math

for key in ncl_relhum.keys():
    assert math.isclose(
        ncl_relhum[key], geocat_relhum[key], rel_tol=1e-05
    )  # within 5 decimal points

import math

for key in ncl_relhum_ice.keys():
    assert math.isclose(
        ncl_relhum_ice[key], geocat_relhum_ice[key], rel_tol=1e-05
    )  # within 5 decimal points