## Plotting Mike21 SW results for SouthShore
# Author: AJMR
# December 22, 2021

# %%  Setup Project
from mikeio import Dfsu, Mesh, Dfs2, Dfs0, Dfs1

import pandas as pd
import pathlib as pl
import numpy as np
import geopandas as gp
import datetime as datetime

import matplotlib as mpl
import matplotlib.pyplot as plt
import time
import matplotlib.animation as animation
import contextily as ctx
import matplotlib.font_manager as fm

# %% Read Model Log

pth = pl.Path("//srv-ott3.baird.com/", "Projects", "13539.101 L'Ansecoy Bay, Mustique", "06_Models",
              "Model Log Mustique.xlsx")

runLog = pd.read_excel(pth.as_posix(), "ModelLog")
# %% Read Map Model Results
modelPlot = [8, 10, 11, 12, 13, 14]
modelPlot = [15, 16, 17]
modelPlot = [18]

dfs_list = [None] * (max(modelPlot) + 1)
ds_list = [None] * (max(modelPlot) + 1)

for m in modelPlot:
    dfsIN = Dfsu(pl.Path(runLog['Run Location'][m], 'fullDomain3D.dfsu').as_posix())

    dfs_list[m]      = dfsIN
    ds_list[m]       = dfs_list[m].read()


# %% Read Model Results at point
modelPlot = [12]

dfs2d_list = [None] * (max(modelPlot) + 1)
dfs3d_list = [None] * (max(modelPlot) + 1)

z_list = [None] * (max(modelPlot) + 1)
z_profile_list = [None] * (max(modelPlot) + 1)

elm_list = [None] * (max(modelPlot) + 1)
elm_df_list = [None] * (max(modelPlot) + 1)

elm2d_list = [None] * (max(modelPlot) + 1)
elm2d_df_list = [None] * (max(modelPlot) + 1)

readPointsName = pd.read_csv("//srv-ott3.baird.com/Projects/13539.101 L'Ansecoy Bay, Mustique/03_Data/03_Field/01_September 2021 trip/Dataset locations_RevF.csv",
                           delimiter=",")
readPoints = pd.read_csv("//srv-ott3.baird.com/Projects/13539.101 L'Ansecoy Bay, Mustique/03_Data/03_Field/01_September 2021 trip/Dataset locations_RevF.csv",
                           delimiter=",").iloc[0:, 2:-2].values

disPipePtsin = gp.read_file('C:/Users/arey/files/Projects/Mustique/DisPipeA_Points6.shp')
disPipePtsin_np = np.array([disPipePtsin.geometry.x.values, disPipePtsin.geometry.y.values])
readPoints = np.vstack((readPoints,disPipePtsin_np.T))

disPipePtsin = gp.read_file('C:/Users/arey/files/Projects/Mustique/DisPipeB_Points2.shp')
disPipePtsin_np = np.array([disPipePtsin.geometry.x.values, disPipePtsin.geometry.y.values])
readPoints = np.vstack((readPoints,disPipePtsin_np.T))

for m in modelPlot:

    # dfsIN = Dfsu(pl.Path(runLog['Run Location'][m], 'fullDomain2D.dfsu').as_posix())
    # dfs2d_list[m] = dfsIN
    #
    # # Read Map
    # # ds_list[m] = dfs_list[m].read()
    # # curU_list[m] = ds_list[m]["Depth averaged U velocity"]
    # # curV_list[m] = ds_list[m]["Depth averaged V velocity"]
    # # curElm_list[m] = dfs_list[m].element_coordinates
    # # wl_list[m] = ds_list[m]["Surface elevation"]
    # # z_list[m] = ds_list[m]["Z coordinate"]
    #
    # ## Read specific points in 2D
    # # Find nearest elements
    # elem_ids = dfs2d_list[m].find_nearest_elements(readPoints[:, 0], readPoints[:, 1])
    # # Read in data from nearest elements
    # elm2d_list[m] = dfs2d_list[m].read(elements=elem_ids)
    #
    # # Convert to Pandas DataFrame
    # elm2d_df_list[m] = [None] * readPoints.shape[0]
    # for p in range(0, readPoints.shape[0]):
    #     elm2d_df_list[m][p] = elm2d_list[m].isel(idx=p).to_dataframe()


    ## Read specific points 3D
    # Setup MIKE object
    dfsIN = Dfsu(pl.Path(runLog['Run Location'][m], 'fullDomain3D.dfsu').as_posix())
    dfs3d_list[m] = dfsIN

    # Find nearest elements
    elem_ids = dfs3d_list[m].find_nearest_profile_elements(readPoints[:, 0], readPoints[:, 1])
    # Read from elements- flatten 2d element array (xy and z) to 1d for reading
    elm_list[m] = dfs3d_list[m].read(elements=elem_ids.flatten().astype(int))

    elm_df_list[m] = [None] * readPoints.shape[0]
    z_profile_list[m] = [None] * readPoints.shape[0]
    # Convert to Pandas DataFrame
    # Loop through points, selecting corresponding depths
    for p in range(0, readPoints.shape[0]):
        z_profile_list[m][p] = dfs3d_list[m].element_coordinates[elem_ids[p, :].astype(int), 2]

        # Convert to Pandas and add zidx
        for z in range(0, z_profile_list[m][p].shape[0]):
            df_tmp = elm_list[m].isel(idx=p * 5 + z).to_dataframe()
            df_tmp['Z'] = z_profile_list[m][p][z]
            df_tmp['Z_IDX'] = z
            if z == 0:
                elm_df_list[m][p] = df_tmp
            else:
                elm_df_list[m][p] = elm_df_list[m][p].append(df_tmp)

            del df_tmp

# %% Import RBR data
rbr_path = "C:/Users/arey/files/Projects/Mustique/041279_20211203_1541Ruskin.xlsx"
rbr_pd = pd.read_excel(rbr_path, sheet_name='Wave', parse_dates=True, header=1, index_col=0)
rbr_pd['WL'] = rbr_pd['Depth'] - rbr_pd['Depth'].mean() - 0.2

# Correct time zone
rbr_pd.index = rbr_pd.index + datetime.timedelta(hours=4)

# %% Import Nortek Eco data
eco_path_1 = "//srv-ott3/Projects/13539.101 L'Ansecoy Bay, Mustique/03_Data/03_Field/01_September 2021 trip/02_Nortek ECO/Eco61_20210910184606.csv"
eco_path_2 = "//srv-ott3/Projects/13539.101 L'Ansecoy Bay, Mustique/03_Data/03_Field/01_September 2021 trip/02_Nortek ECO/Eco214_20210902120703.csv"

eco1_pd = pd.read_csv(eco_path_1, sep=',', header=[28], index_col=0,
                      parse_dates=False)

eco2_pd = pd.read_csv(eco_path_2, sep=',', header=[28], index_col=0,
                      parse_dates=False)

# Drop first row
eco1_pd.drop(eco1_pd.index[0], inplace=True)
eco2_pd.drop(eco2_pd.index[0], inplace=True)

eco1_pd.index = pd.to_datetime(eco1_pd.index, format='%m/%d/%Y %I:%M:%S %p')
eco2_pd.index = pd.to_datetime(eco2_pd.index, format='%m/%d/%Y %I:%M:%S %p')

# Set water level to zero
eco1_pd['WL'] = eco1_pd['Depth'].astype(float) - eco1_pd['Depth'].astype(float).mean(skipna=True) + 0.2
eco2_pd['WL'] = eco2_pd['Depth'].astype(float) - eco2_pd['Depth'].astype(float).mean(skipna=True) + 0.2

# Correct time zone
eco1_pd.index = eco1_pd.index + datetime.timedelta(hours=4)
eco2_pd.index = eco2_pd.index + datetime.timedelta(hours=4)

# %% Read in boundary conditions
ds_wl = []

dfs1 = Dfs1("//oak-spillway.baird.com/D/13539.101 L'Ansecoy Bay, Mustique/MIKE3/02_Bounds/NCOM2_EastBound.dfs1")
ds_wl.append(dfs1.read())

dfs1 = Dfs1("//oak-spillway.baird.com/D/13539.101 L'Ansecoy Bay, Mustique/MIKE3/02_Bounds/NCOM2_NorthBound.dfs1")
ds_wl.append(dfs1.read())

dfs1 = Dfs1("//oak-spillway.baird.com/D/13539.101 L'Ansecoy Bay, Mustique/MIKE3/02_Bounds/NCOM2_SouthBound.dfs1")
ds_wl.append(dfs1.read())

dfs1 = Dfs1("//oak-spillway.baird.com/D/13539.101 L'Ansecoy Bay, Mustique/MIKE3/02_Bounds/NCOM2_WestBound.dfs1")
ds_wl.append(dfs1.read())

# %% Plot Water Level at a point
fig, axes = plt.subplots(nrows=3, ncols=1, figsize=(8, 8), sharex=True)
plotstart = '2021-10-01 00:00:00'
plotend   = '2021-10-15 00:00:00'
# plotstart = '2021-10-05 00:00:00'
# plotend   = '2021-10-07 00:00:00'
modelPlot = [13]

for m in modelPlot:
    for sub, p in enumerate([5, 9, 6]):

        if p == 9:
            rbr_pd['WL'].plot(ax=axes[sub], color='k', label='Nearshore East Obervations')
        elif p == 5:
            eco1_pd['WL'].plot(ax=axes[sub], color='k', label='Offshore Obervations')
        elif p == 6:
            eco2_pd['WL'].plot(ax=axes[sub], color='k', label='Nearshore West Obervations')

        elm2d_df_list[m][p].plot(y='Surface elevation', ax=axes[sub], label='Model')
        axes[sub].legend(loc="upper left")

        axes[sub].set_xlim(pd.Timestamp(plotstart), pd.Timestamp(plotend))
        axes[sub].set_ylim(-1.0, 1.0)
        axes[sub].set_ylabel('Water Level (m)')

axes[sub].set_xlabel('Date')

plt.show()
fig.savefig('//srv-ott3.baird.com/Projects/13539.101 L\'Ansecoy Bay, Mustique/06_Models/01_MIKE3/00_Figures/' +
            '/wl_TS_RevB.png', bbox_inches='tight')

# %% Velocity point U and V
# Z_IDX = 4
# ecoVar1 = 'Upper speed U'
# ecoVar2 = 'Upper speed V'
# ecoVar3 = 'Upper speed'
# ecoVar4 = 'Upper direction'

# plotstart = '2021-09-14 00:00:00'
# # plotend = '2021-09-16 00:00:00'
# plotend = '2021-10-03 00:00:00'

plotstart = '2021-10-01 00:00:00'
# plotend = '2021-09-16 00:00:00'
plotend = '2021-10-21 00:00:00'

# plotstart = '2021-10-05 00:00:00'
# plotend   = '2021-10-07 00:00:00'

Z_IDX = 2
ecoVar1 = 'Middle speed U'
ecoVar2 = 'Middle speed V'
ecoVar3 = 'Middle speed'
ecoVar4 = 'Middle direction'

# Z_IDX = 1
# ecoVar1 = 'Lower speed U'
# ecoVar2 = 'Lower speed V'
# ecoVar3 = 'Lower speed'
# ecoVar4 = 'Lower direction'

fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(8, 4), sharex=True)
modelPlot = [13]

for m in modelPlot:
    eco1_pd[ecoVar1] = eco1_pd[ecoVar3].astype(float) * \
                       np.sin(np.radians(eco1_pd[ecoVar4].astype(float).to_numpy()))

    eco1_pd[ecoVar1].astype(float).plot(ax=axes[0], color='k', label='Observations')
    elm_df_list[m][3].loc[elm_df_list[m][5]['Z_IDX'] == Z_IDX, :].plot(
        y='U velocity', ax=axes[0], label='Model')

    axes[0].set_ylim(-0.5, 0.5)
    axes[0].set_xlim(pd.Timestamp(plotstart), pd.Timestamp(plotend))
    axes[0].set_ylabel('Nearshore U (m/s)')
    axes[0].legend(bbox_to_anchor=(0.90, 1), loc="upper left")

    eco1_pd[ecoVar2] = eco1_pd[ecoVar3].astype(float) * \
                       np.cos(np.radians(eco1_pd[ecoVar4].astype(float).to_numpy()))

    eco1_pd[ecoVar2].astype(float).plot(ax=axes[1], color='k', label='Observations')

    elm_df_list[m][5].loc[elm_df_list[m][5]['Z_IDX'] == Z_IDX, :].plot(
        y='V velocity', ax=axes[1], label='Model')


    axes[1].set_ylim(-0.5, 0.5)
    axes[1].set_xlim(pd.Timestamp(plotstart), pd.Timestamp(plotend))
    axes[1].set_ylabel('Nearshore V (m/s)')
    axes[1].legend(bbox_to_anchor=(0.90, 1), loc="upper left")

    # eco2_pd[ecoVar1] = eco2_pd[ecoVar3].astype(float) * \
    #                    np.sin(np.radians(eco2_pd[ecoVar4].astype(float).to_numpy()))
    # eco2_pd[ecoVar1].astype(float).plot(ax=axes[2], color='k', label='Observations')
    # elm_df_list[m][6].loc[elm_df_list[m][6]['Z_IDX'] == Z_IDX, :].plot(
    #     y='U velocity', ax=axes[2], label='Model')

    # axes[2].set_ylim(-1.5, 1.5)
    # axes[2].set_xlim(pd.Timestamp(plotstart), pd.Timestamp(plotend))
    # axes[2].set_ylabel('Offshore U (m/s)')
    # axes[2].legend(bbox_to_anchor=(0.90, 1), loc="upper left")
    #
    # eco2_pd[ecoVar2] = eco2_pd[ecoVar3].astype(float) * \
    #                    np.cos(np.radians(eco2_pd[ecoVar4].astype(float).to_numpy()))
    # eco2_pd[ecoVar2].astype(float).plot(ax=axes[3], color='k', label='Observations')
    # elm_df_list[m][5].loc[elm_df_list[m][6]['Z_IDX'] == Z_IDX, :].plot(
    #     y='V velocity', ax=axes[3], label='Model')
    #
    # axes[3].set_ylim(-1.00, 1.00)
    # axes[3].set_xlim(pd.Timestamp(plotstart), pd.Timestamp(plotend))
    # axes[3].set_ylabel('Offshore V (m/s)')
    # axes[3].legend(bbox_to_anchor=(0.90, 1), loc="upper left")

    axes[1].set_xlabel('Date')

plt.show()
fig.savefig('//srv-ott3.baird.com/Projects/13539.101 L\'Ansecoy Bay, Mustique/06_Models/01_MIKE3/00_Figures/' +
            '/uVel_TS_RevC.png', bbox_inches='tight')


# %% Subplot Map Plotting
mapbox = 'https://api.mapbox.com/styles/v1/alexander0042/ckex9vtri0o6619p55sl5qiyv/tiles/256/{z}/{x}/{y}@2x?access_token=pk.eyJ1IjoiYWxleGFuZGVyMDA0MiIsImEiOiJjazVmdG4zbncwMHY4M2VrcThwZGUzZDFhIn0.w6oDHoo1eCeRlSBpwzwVtw'
x, y, arrow_length = 0.93, 0.95, 0.12
fontprops = fm.FontProperties(size=12)
modelPlot = [18]

tStepsPlot = np.zeros((5, 6))
tStepsPlot[0, :] = range(110, 116)
tStepsPlot[1, :] = range(158, 164)
tStepsPlot[2, :] = range(206, 212)
tStepsPlot[3, :] = range(255, 261)
tStepsPlot[4, :] = range(138, 144)

for m in modelPlot:
    vmax = 34.0
    vmin = 33.7
    cmap = 'inferno'

    if m == 8 or m == 17:
        disPlot = 7
    elif m == 11 or m == 15 or m == 18:
        disPlot = 13
    elif m == 14 or m == 16:
        disPlot = 8

    for a in range(0, 5):
        fig, axes = plt.subplots(nrows=2, ncols=3, sharey=True, sharex=True, figsize=(16, 9))
        ax = axes.flatten()
        for t in range(0, 6):
            # Plot salinity
            # Select salinity data at selected time step
            plotDat = ds_list[m]['Salinity'][int(tStepsPlot[a, t]), :]
            # Identify nan values
            plot_nan = np.isnan(plotDat)

            # Add additional nan values to show bed
            plot_nan = plot_nan | (plotDat < 33.725)

            # Plot all selected values at a given later and not nan
            axDHI = dfs_list[m].plot(plotDat[(dfs_list[m].layer_ids == 0) & (~plot_nan)], plot_type='contourf',
                                     show_mesh=False, cmap=cmap, ax=ax[t], add_colorbar=False,
                                     vmin=vmin, vmax=vmax,
                                     elements=dfs_list[m].element_ids[(dfs_list[m].layer_ids == 0) & (~plot_nan)])
            # Add discharge point
            ax[t].scatter(readPoints[disPlot, 0], readPoints[disPlot, 1], marker='^', color='r', s=20)

            # ax[t].set_xlim(left=696680.7, right=698252.7)
            # ax[t].set_ylim(bottom=1425547.5, top=1426681.8)
            ax[t].set_xlim(left=696508.3, right=698252.7)
            ax[t].set_ylim(bottom=1425267.0, top=1426681.8)

            ctx.add_basemap(ax[t], source=mapbox, crs='EPSG:32620')
            ax[t].title.set_text(str(ds_list[m].time[int(tStepsPlot[a, t])]))
            ax[t].xaxis.set_major_locator(plt.MaxNLocator(4))
            # axes.titlesize = 'x-large'
            # fig.suptitle(runLog['Short Description'][m], fontsize=18)
            # ax[t].set_xlabel('Easting [m]')
            # ax[t].set_ylabel('Northing [m]')

        fig.subplots_adjust(right=0.8)
        cmap = mpl.cm.inferno
        norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
        cax = plt.axes([0.85, 0.2, 0.05, 0.6])
        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap,
                                        norm=norm,
                                        orientation='vertical')
        cb1.set_label('Salinity (PSU)')
        plt.show()
        fig.savefig('//srv-ott3.baird.com/Projects/13539.101 L\'Ansecoy Bay, Mustique/06_Models/01_MIKE3/00_Figures/' +
                    '/Plume_6_Plot_' + runLog['Run'][m][0:-20] +'_Alt' + str(a) + '.png', bbox_inches='tight')

# %% Map Plotting
mapbox = 'https://api.mapbox.com/styles/v1/alexander0042/ckex9vtri0o6619p55sl5qiyv/tiles/256/{z}/{x}/{y}@2x?access_token=pk.eyJ1IjoiYWxleGFuZGVyMDA0MiIsImEiOiJjazVmdG4zbncwMHY4M2VrcThwZGUzZDFhIn0.w6oDHoo1eCeRlSBpwzwVtw'
x, y, arrow_length = 0.93, 0.95, 0.12
fontprops = fm.FontProperties(size=12)
modelPlot = range(8, 9)

for m in modelPlot:
    vmax = 34.2
    vmin = 34

    fig, axes = plt.subplots(figsize=(8, 8))

    # Plot salinity
    # Select salinity data at last time step
    plotDat = ds_list[m]['Salinity'][-1, :]
    # Identify nan values
    plot_nan = np.isnan(plotDat)

    # Add additional nan values to show bed
    plot_nan = plot_nan | (plotDat<34.05)

    # Plot all selected values at a given later and not nan
    axDHI = dfs_list[m].plot(plotDat[(dfs_list[m].layer_ids == 1) & (~plot_nan)], plot_type='contourf',
                             show_mesh=False, cmap='inferno', ax=axes,
                             vmin=vmin, vmax=vmax, label='Salinity (PSU)',
                             elements=dfs_list[m].element_ids[(dfs_list[m].layer_ids == 1) & (~plot_nan)])


    axes.set_xlim(left=696680.7, right=698252.7)
    axes.set_ylim(bottom=1425547.5, top=1426681.8)

    ctx.add_basemap(axes, source=mapbox, crs='EPSG:32620')
    # axes.title.set_text(runLog['Short Description'][m])
    # axes.titlesize = 'x-large'
    # fig.suptitle(runLog['Short Description'][m], fontsize=18)
    axes.set_xlabel('Easting [m]')
    axes.set_ylabel('Northing [m]')

    plt.show()


# %% Animated map
plt.rcParams['animation.ffmpeg_path'] = 'C:/Users/arey/Local/ffmpeg-2022-02-14-git-59c647bcf3-full_build/bin/ffmpeg.exe'

mapbox = 'https://api.mapbox.com/styles/v1/alexander0042/ckex9vtri0o6619p55sl5qiyv/tiles/256/{z}/{x}/{y}@2x?access_token=pk.eyJ1IjoiYWxleGFuZGVyMDA0MiIsImEiOiJjazVmdG4zbncwMHY4M2VrcThwZGUzZDFhIn0.w6oDHoo1eCeRlSBpwzwVtw'
x, y, arrow_length = 0.93, 0.95, 0.12
fontprops = fm.FontProperties(size=12)

# Set model to plot
modelPlot = [15, 16, 17]
m = 16

# m = 11
vmax = 34.0
vmin = 33.7
cmap = 'inferno'

metadata = dict(title='Movie Test', artist='Matplotlib',
                comment='Movie support')
writer = animation.FFMpegWriter(fps=2, metadata=metadata, codec='h264')
fig, axes = plt.subplots(figsize=(8, 8))

writer.setup(fig, 'C:/Users/arey/files/Projects/Mustique/' +
             runLog['Run'][m][0:-20] + 'Intake.mp4')

# Animation function
for i in np.arange(1, 384, 1): #384
    if m == 8 or m == 17:
        disPlot = 7
    elif m == 11 or m == 15:
        disPlot = 13
    elif m == 14 or m == 16:
        disPlot = 8

    # fig, axes = plt.subplots(figsize=(8, 8))
    axes.cla()

    # Plot salinity
    # Select salinity data at last time step
    plotDat = ds_list[m]['Salinity'][i, :]
    # Identify nan values
    plot_nan = np.isnan(plotDat)

    # Add additional nan values to show bed
    plot_nan = plot_nan | (plotDat<33.725)

    # Plot all selected values at a given later and not nan
    axDHI = dfs_list[m].plot(plotDat[(dfs_list[m].layer_ids == 0) & (~plot_nan)], plot_type='contourf',
                             show_mesh=False, cmap='inferno', ax=axes, add_colorbar=False,
                             vmin=vmin, vmax=vmax, label='Salinity (PSU)', levels=24,
                             elements=dfs_list[m].element_ids[(dfs_list[m].layer_ids == 0) & (~plot_nan)])

    axes.scatter(readPoints[disPlot, 0], readPoints[disPlot, 1], marker='^', color='r', s=20)
    # axes.set_xlim(left=696680.7, right=698252.7)
    # axes.set_ylim(bottom=1425547.5, top=1426681.8)
    axes.set_xlim(left=696508.3, right=698252.7)
    axes.set_ylim(bottom=1425267.0, top=1426681.8)

    ctx.add_basemap(axes, source=mapbox, crs='EPSG:32620')
    axes.set_xlabel('Easting [m]')
    axes.set_ylabel('Northing [m]')

    axes.title.set_text(str(ds_list[m].time[i]))

    if i == 1:
        fig.subplots_adjust(right=0.8)
        cmap = mpl.cm.inferno
        norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
        cax = plt.axes([0.82, 0.25, 0.04, 0.5])
        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap,
                                        norm=norm,
                                        orientation='vertical')
        cb1.set_label('Salinity (PSU)')


    writer.grab_frame()
    # plt.show()
    print(i)

writer.finish()


# %% Plot Bathymetry

fig, axes = plt.subplots(figsize=(8, 8))
# Convert to feet and ignore missing
axDHI = dfs_list[m].plot(bed_plot[~bed_nan], plot_type='contourf', show_mesh=False, cmap='magma_r', ax=axes, levels=9,
                         vmin=-80, vmax=0, label='Bed Elevation (ft)',
                         elements=dfs_list[m].element_ids[~bed_nan])

axes.set_xlim(left=427800, right=431000)
axes.set_ylim(bottom=4758000, top=4762500)

ctx.add_basemap(axes, source=mapbox, crs='EPSG:32620')

fig.suptitle('Bed Elevation', fontsize=18)
axes.set_xlabel('Easting [m]')
axes.set_ylabel('Northing [m]')

plt.show()

# fig.savefig(
#     '//srv-mad3/Projects/13632.101 South Shore Breakwater/10_Reports&Pres/13632.101.R3 Ph I BOD/Support files/' +
#     'Bed_Elevation.png', bbox_inches='tight', dpi=300)

# %% Read time series
MIKEds_list = [None] * (max(modelPlot) + 1)
MIKEdsT_list = [None] * (max(modelPlot) + 1)

for m in modelPlot:
    dfsIN = Dfs0(pl.Path(runLog['Run Location'][m], str(runLog['Number'][m]) + '_' +
                         runLog['Run Name'][m] + '.sw - Result Files', 'BreakPts.dfs0').as_posix())
    dfsIN_read = dfsIN.read()
    MIKEds_list[m] = dfsIN_read.to_dataframe()

    dfsTIN = Dfs0(pl.Path(runLog['Run Location'][m], str(runLog['Number'][m]) + '_' +
                          runLog['Run Name'][m] + '.sw - Result Files', 'TransectPTS.dfs0').as_posix())
    dfsTIN_read = dfsTIN.read()
    MIKEdsT_list[m] = dfsTIN_read.to_dataframe()

    # Cleanup unnecessary variables
    del dfsIN_read
    del dfsIN
    del dfsTIN_read
    del dfsTIN

# %% Read in Toe and Crest Shapefiles
breakwaterPTS = gp.read_file("//srv-mad3.baird.com/Projects/"
                             "13632.101 South Shore Breakwater/08_CADD/Outgoing/"
                             "20211211_Toe Extents (to Alexander)/"
                             "20211211_Toe_Extents_NAD83_WISStatePlaneSZn_USFt_Lines_OffshoreClipSimple_10m_vertexUTM.shp")
breakCrest = pd.read_csv(
    '//srv-mad3.baird.com/Projects/13632.101 South Shore Breakwater/08_CADD/Outgoing/20211214_Crest Points (to Alexander)/20211214_Crest_Points_m.csv',
    header=None, names=['x', 'y', 'z'])
breakCrest_gdf = gp.GeoDataFrame(breakCrest, crs='EPSG:32154',
                                 geometry=gp.points_from_xy(breakCrest.x, breakCrest.y))
breakCrest_gdf.to_crs('EPSG:32616', inplace=True)

breakwaterPTS_Crest = breakwaterPTS.sjoin_nearest(breakCrest_gdf)
breakwaterPTS_Crest.rename(columns={'x': 'breakCrest_x', 'y': 'breakCrest_y', 'z': 'Crest'}, inplace=True)

# %% Merge with data
breakPointsOut = [None] * (max(modelPlot) + 1)
breakTimesOut = [None] * (max(modelPlot) + 1)

for m in modelPlot:
    breakwaterPTS_times = None

    for t in range(0, MIKEds_list[m].shape[0]):
        breakwaterPTS_merge = None
        breakwaterPTS_merge = breakwaterPTS_Crest

        for i in range(0, MIKEds_list[m].shape[1]):
            paramName = MIKEds_list[m].columns.values[i][MIKEds_list[m].columns.values[i].find('"', 5, -1) + 3:]
            if paramName not in breakwaterPTS_merge.columns:
                breakwaterPTS_merge[paramName] = np.full([breakwaterPTS_merge.shape[0], 1], np.nan)
            tmpFID = int(MIKEds_list[m].columns.values[i][1:MIKEds_list[m].columns.values[i].find('"', 1)])
            tmpIND = int(MIKEds_list[m].columns.values[i][5:MIKEds_list[m].columns.values[i].find('"', 5)])

            breakwaterPTS_merge.loc[((breakwaterPTS_merge.FID == tmpFID) &
                                     (breakwaterPTS_merge.vertex_ind == tmpIND)),
                                    paramName] = MIKEds_list[m].iloc[t, i]

        breakwaterPTS_merge['Time'] = MIKEds_list[m].index[t]

        breakwaterPTS_times = pd.concat([breakwaterPTS_times, breakwaterPTS_merge], ignore_index=True)

    breakTimesOut[m] = breakwaterPTS_times

# %% Read in Breakwater Transect Points Sh
breakwaterT = pd.read_csv("C:/Users/arey/files/Projects/SouthShore/Bathy/BreakTransectPTS_Names.csv", sep='\t')

breakwaterT_PTS = gp.GeoDataFrame(breakwaterT, geometry=gp.points_from_xy(breakwaterT.X, breakwaterT.Y),
                                  crs='EPSG:32616')

# %% Merge with data
breakPoints_TOut = [None] * (max(modelPlot) + 1)
breakTimes_TOut = [None] * (max(modelPlot) + 1)

for m in modelPlot:
    breakwaterPTS_times = None

    for t in range(0, MIKEdsT_list[m].shape[0]):
        breakwaterPTS_merge = None
        breakwaterPTS_merge = breakwaterT_PTS

        for i in range(0, MIKEdsT_list[m].shape[1]):
            paramName = MIKEdsT_list[m].columns.values[i][MIKEdsT_list[m].columns.values[i].find(':', 5, -1) + 2:]
            if paramName not in breakwaterPTS_merge.columns:
                breakwaterPTS_merge[paramName] = np.full([breakwaterPTS_merge.shape[0], 1], np.nan)
            tmpName = MIKEdsT_list[m].columns.values[i][0:MIKEdsT_list[m].columns.values[i].find(':', 1)]

            breakwaterPTS_merge.loc[(breakwaterPTS_merge.Name == tmpName),
                                    paramName] = MIKEdsT_list[m].iloc[t, i]

        breakwaterPTS_merge['Time'] = MIKEdsT_list[m].index[t]

        breakwaterPTS_times = pd.concat([breakwaterPTS_times, breakwaterPTS_merge], ignore_index=True)

    breakTimes_TOut[m] = breakwaterPTS_times

# %% Format and save

for m in modelPlot:
    saveTmp = breakTimesOut[m].copy()
    saveTmp['X'] = saveTmp.geometry.x
    saveTmp['Y'] = saveTmp.geometry.y
    saveTmp.drop(['vertex_par', 'vertex_p_1', 'angle', 'geometry', 'index_right',
                  'breakCrest_x', 'breakCrest_y', 'Length'], axis=1, inplace=True)
    saveTmp.sort_values(by=['FID', 'vertex_ind'], inplace=True, ignore_index=True)

    # Reorder columns
    colNames = saveTmp.columns.values
    saveTmp = saveTmp[['X', 'Y', *colNames[0:-2]]]
    saveTmpT = saveTmp.transpose(copy=True)

    # Transect points
    saveTmp2 = breakTimes_TOut[m].copy()
    saveTmp2.drop(['geometry'], axis=1, inplace=True)
    saveTmp2T = saveTmp2.transpose(copy=True)

    saveTmpT.to_csv('//srv-mad3.baird.com/Projects/13632.101 South Shore Breakwater/06_Models/02_Mike21SW/Results/' +
                    'Toe' + runLog['Short Description'][m] + '.csv')

    saveTmp2T.to_csv('//srv-mad3.baird.com/Projects/13632.101 South Shore Breakwater/06_Models/02_Mike21SW/Results/' +
                     'Transect' + runLog['Short Description'][m] + '.csv')


# %% Setup path along pipe transect
m = 12

df_time_rows = elm_df_list[m][0].Z.drop_duplicates()
df_time_rowsidx = np.where(df_time_rows.index.values[0] == elm_df_list[m][0].index.values)[0]

tSteps = range(100, 2000)


u_plotarray = np.zeros((2000, 5, 81))
for layer in range(0, 5):
    for tStep in tSteps:
        u_plotarray[tStep, layer, :] = [x.iloc[df_time_rowsidx[layer] + tStep, 0] for x in elm_df_list[m]]

v_plotarray = np.zeros((2000, 5, 81))
for layer in range(0, 5):
    for tStep in tSteps:
        v_plotarray[tStep, layer, :] = [x.iloc[df_time_rowsidx[layer] + tStep, 0] for x in elm_df_list[m]]

mag_plotarray = np.sqrt(u_plotarray ** 2 + v_plotarray ** 2)

max_plotarray = np.max(mag_plotarray, axis=0)

# Find layer depths along transect and interpolate along vertical profile
layer_depth     = np.zeros((5, 81))
max_plot_interp = np.zeros((60, 81))
interp_depths   = np.arange(-6, 0, 0.1)

for chain in range(14, 81):
    layer_depth[:, chain] = elm_df_list[m][chain].Z.unique()
    max_plot_interp[:, chain] = np.interp(interp_depths, layer_depth[:, chain], max_plotarray[:, chain])
    # Set points below bed as nan
    max_plot_interp[interp_depths<layer_depth[0, chain], chain] = np.nan

# %% Plot along transect

fig, axes = plt.subplots(figsize=(8, 8))
# plt.pcolor(np.arange(0, 67*5, 5), elm_df_list[m][0].Z.unique(), max_plotarray[:, 14:], cmap='jet')
# for chain in range(15, 81):
    # plt.pcolor([(chain-15) * 5, (chain-14) * 5], layer_depth[:, chain-1:chain+1], max_plotarray[:, chain-1:chain+1], cmap='jet')

axes.set_ylabel('Depth (m)')
axes.set_xlabel('Distance along discharge pipe (m). Existing Pipe at 170 m')

plt.pcolor(np.arange(0, 67*5, 5), interp_depths, max_plot_interp[:, 14:], cmap='jet')
plt.colorbar(label="Maximum Current Speed (m/s)")
plt.show()

pth = pl.Path("//srv-ott3.baird.com/", "Projects", "13539.101 L'Ansecoy Bay, Mustique", "06_Models", "01_MIKE3", "00_Figures",
              "Discharge Velocity.png")

fig.savefig(pth.as_posix(), bbox_inches='tight', dpi=300)
