# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""Helper functions for the figures in the paper."""
import os.path as op
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.font_manager import FontProperties


def plot_qi2(x_grid, ref_pdf, fit_pdf, ref_data, cutoff_idx, out_file=None):
    fig, ax = plt.subplots()

    ax.plot(
        x_grid, ref_pdf, linewidth=2, alpha=0.5, label="background", color="dodgerblue"
    )

    refmax = np.percentile(ref_data, 99.95)
    x_max = x_grid[-1]

    ax.hist(
        ref_data,
        40 * max(int(refmax / x_max), 1),
        fc="dodgerblue",
        histtype="stepfilled",
        alpha=0.2,
        normed=True,
    )
    fit_pdf[fit_pdf > 1.0] = np.nan
    ax.plot(x_grid, fit_pdf, linewidth=2, alpha=0.5, label="chi2", color="darkorange")

    ylims = ax.get_ylim()
    ax.axvline(
        x_grid[-cutoff_idx], ymax=ref_pdf[-cutoff_idx] / ylims[1], color="dodgerblue"
    )
    plt.xlabel('Intensity within "hat" mask')
    plt.ylabel("Frequency")
    ax.set_xlim([0, x_max])
    plt.legend()

    if out_file is None:
        out_file = op.abspath("qi2_plot.svg")

    fig.savefig(out_file, bbox_inches="tight", pad_inches=0, dpi=300)
    return out_file


def plot_batches(fulldata, cols=None, out_file=None, site_labels="left"):
    fulldata = fulldata.sort_values(by=["database", "site"]).copy()
    sites = fulldata.site.values.ravel().tolist()
    if cols is None:
        numdata = fulldata.select_dtypes([np.number])
    else:
        numdata = fulldata[cols]

    numdata = numdata[cols]
    colmin = numdata.min()
    numdata = numdata - colmin
    colmax = numdata.max()
    numdata = numdata / colmax

    fig, ax = plt.subplots(figsize=(20, 10))
    ax.imshow(
        numdata.values, cmap=plt.cm.viridis, interpolation="nearest", aspect="auto"
    )

    locations = []
    spines = []
    fulldata["index"] = range(len(fulldata))
    for site in list(set(sites)):
        indices = fulldata.loc[fulldata.site == site, "index"].values.ravel().tolist()
        locations.append(int(np.average(indices)))
        spines.append(indices[0])

    if site_labels == "right":
        ax.yaxis.tick_right()
        ax.yaxis.set_label_position("right")

    plt.xticks(
        range(numdata.shape[1]), numdata.columns.ravel().tolist(), rotation="vertical"
    )
    plt.yticks(locations, list(set(sites)))
    for line in spines[1:]:
        plt.axhline(y=line, color="w", linestyle="-")
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)
    # ax.spines['left'].set_visible(False)
    ax.spines["bottom"].set_visible(False)
    ax.grid(False)

    ticks_font = FontProperties(
        family="FreeSans", style="normal", size=14, weight="normal", stretch="normal"
    )
    for label in ax.get_yticklabels():
        label.set_fontproperties(ticks_font)

    ticks_font = FontProperties(
        family="FreeSans", style="normal", size=12, weight="normal", stretch="normal"
    )
    for label in ax.get_xticklabels():
        label.set_fontproperties(ticks_font)

    if out_file is not None:
        fig.savefig(out_file, bbox_inches="tight", pad_inches=0, dpi=300)
    return fig


def plot_roc_curve(true_y, prob_y, out_file=None):
    from sklearn.metrics import roc_curve

    fpr, tpr, _ = roc_curve(true_y, prob_y)

    fig = plt.figure()
    plt.plot(fpr, tpr, color="darkorange", lw=2, label="ROC curve")
    plt.plot([0, 1], [0, 1], color="navy", lw=1, linestyle="--")
    plt.xlim([-0.025, 1.025])
    plt.ylim([-0.025, 1.025])
    plt.xlabel("False Positive Rate")
    plt.ylabel("True Positive Rate")
    plt.title("RoC Curve")
    if out_file is not None:
        fig.savefig(out_file)
    return fig


def fill_matrix(matrix, width, value="n/a"):
    if matrix.shape[0] < width:
        nraters = matrix.shape[1]
        nas = np.chararray((1, nraters), itemsize=len(value))
        nas[:] = value
        matrix = np.vstack(tuple([matrix] + [nas] * (width - matrix.shape[0])))
    return matrix


def plot_raters(dataframe, ax=None, width=101, size=0.40):
    raters = sorted(dataframe.columns.ravel().tolist())
    dataframe["notnan"] = np.any(np.isnan(dataframe[raters]), axis=1).astype(int)
    dataframe = dataframe.sort_values(by=["notnan"] + raters, ascending=True)
    for rater in raters:
        dataframe[rater] = dataframe[[rater]].astype(str)

    matrix = dataframe.as_matrix()
    nsamples, nraters = dataframe.shape
    matrix = fill_matrix(matrix, width)

    nblocks = 1
    if matrix.shape[0] > width:
        matrices = []
        nblocks = (matrix.shape[0] // width) + 1

        nas = np.chararray((width, 1), itemsize=3)
        nas[:] = "n/a"
        for i in range(nblocks):
            if i > 0:
                matrices.append(nas)
            matrices.append(matrix[i * width:(i + 1) * width, ...])

        matrices[-1] = fill_matrix(matrices[-1], width)
        matrix = np.hstack(tuple(matrices))

    palette = {"1.0": "limegreen", "0.0": "dimgray", "-1.0": "tomato", "n/a": "w"}

    ax = ax if ax is not None else plt.gca()

    # ax.patch.set_facecolor('gray')
    ax.set_aspect("equal", "box")
    ax.xaxis.set_major_locator(plt.NullLocator())
    ax.yaxis.set_major_locator(plt.NullLocator())
    nrows = ((nsamples - 1) // width) + 1
    xlims = (-14.0, width)
    ylims = (-0.07 * nraters, nrows * nraters + nraters * 0.07 + (nrows - 1))

    ax.set_xlim(xlims)
    ax.set_ylim(ylims)

    offset = 0.5 * (size / 0.40)
    for (x, y), w in np.ndenumerate(matrix):
        if w not in list(palette.keys()):
            w = "n/a"

        color = palette[w]
        rect = plt.Circle(
            [x + offset, y + offset], size, facecolor=color, edgecolor=color
        )
        ax.add_patch(rect)

    # text_x = ((nsamples - 1) % width) + 6.5
    text_x = -8.5
    for i, rname in enumerate(raters):
        nsamples = sum(dataframe[rname] != "n/a")
        good = 100 * sum(dataframe[rname] == "1.0") / nsamples
        bad = 100 * sum(dataframe[rname] == "-1.0") / nsamples

        text_y = 1.5 * i + (nrows - 1) * 2.0
        ax.text(
            text_x,
            text_y,
            "%2.0f%%" % good,
            color="limegreen",
            weight=1000,
            size=16,
            horizontalalignment="right",
            verticalalignment="center",
            transform=ax.transData,
        )
        ax.text(
            text_x + 3.50,
            text_y,
            "%2.0f%%" % max((0.0, 100 - good - bad)),
            color="dimgray",
            weight=1000,
            size=16,
            horizontalalignment="right",
            verticalalignment="center",
            transform=ax.transData,
        )
        ax.text(
            text_x + 7.0,
            text_y,
            "%2.0f%%" % bad,
            color="tomato",
            weight=1000,
            size=16,
            horizontalalignment="right",
            verticalalignment="center",
            transform=ax.transData,
        )

    # ax.autoscale_view()
    ax.invert_yaxis()
    plt.grid(False)

    # Remove and redefine spines
    for side in ["top", "right", "bottom"]:
        # Toggle the spine objects
        ax.spines[side].set_color("none")
        ax.spines[side].set_visible(False)

    ax.spines["left"].set_linewidth(1.5)
    ax.spines["left"].set_color("dimgray")
    # ax.spines["left"].set_position(('data', xlims[0]))

    ax.set_yticks([0.5 * (ylims[0] + ylims[1])])
    ax.tick_params(axis="y", which="major", pad=15)

    ticks_font = FontProperties(
        family="FreeSans", style="normal", size=20, weight="normal", stretch="normal"
    )
    for label in ax.get_yticklabels():
        label.set_fontproperties(ticks_font)

    return ax


def raters_variability_plot(
    mdata,
    figsize=(22, 22),
    width=101,
    out_file=None,
    raters=("rater_1", "rater_2", "rater_3"),
    only_overlap=True,
    rater_names=("Rater 1", "Rater 2a", "Rater 2b"),
):
    if only_overlap:
        mdata = mdata[np.all(~np.isnan(mdata[raters]), axis=1)]
    # Swap raters 2 and 3
    # i, j = cols.index('rater_2'), cols.index('rater_3')
    # cols[j], cols[i] = cols[i], cols[j]
    # mdata.columns = cols

    sites_list = sorted(set(mdata.site.values.ravel().tolist()))
    sites_len = []
    for site in sites_list:
        sites_len.append(len(mdata.loc[mdata.site == site]))

    sites_len, sites_list = zip(*sorted(zip(sites_len, sites_list)))

    blocks = [(slen - 1) // width + 1 for slen in sites_len]
    fig = plt.figure(figsize=figsize)
    gs = GridSpec(
        len(sites_list), 1, width_ratios=[1], height_ratios=blocks, hspace=0.05
    )

    for s, gsel in zip(sites_list, gs):
        ax = plt.subplot(gsel)
        plot_raters(
            mdata.loc[mdata.site == s, raters],
            ax=ax,
            width=width,
            size=0.40 if len(raters) == 3 else 0.80,
        )
        ax.set_yticklabels([s])

    # ax.add_line(Line2D([0.0, width], [8.0, 8.0], color='k'))
    # ax.annotate(
    #     '%d images' % width, xy=(0.5 * width, 8), xycoords='data',
    #     xytext=(0.5 * width, 9), fontsize=20, ha='center', va='top',
    #     arrowprops=dict(arrowstyle='-[,widthB=1.0,lengthB=0.2', lw=1.0)
    # )

    # ax.annotate('QC Prevalences', xy=(0.1, -0.15), xytext=(0.5, -0.1), xycoords='axes fraction',
    #         fontsize=20, ha='center', va='top',
    #         arrowprops=dict(arrowstyle='-[, widthB=3.0, lengthB=0.2', lw=1.0))

    newax = plt.axes([0.6, 0.65, 0.25, 0.16])
    newax.grid(False)
    newax.set_xticklabels([])
    newax.set_xticks([])
    newax.set_yticklabels([])
    newax.set_yticks([])

    nsamples = len(mdata)
    for i, rater in enumerate(raters):
        nsamples = len(mdata) - sum(np.isnan(mdata[rater].values))
        good = 100 * sum(mdata[rater] == 1.0) / nsamples
        bad = 100 * sum(mdata[rater] == -1.0) / nsamples

        text_x = 0.92
        text_y = 0.5 - 0.17 * i
        newax.text(
            text_x - 0.36,
            text_y,
            "%2.1f%%" % good,
            color="limegreen",
            weight=1000,
            size=25,
            horizontalalignment="right",
            verticalalignment="center",
            transform=newax.transAxes,
        )
        newax.text(
            text_x - 0.18,
            text_y,
            "%2.1f%%" % max((0.0, 100 - good - bad)),
            color="dimgray",
            weight=1000,
            size=25,
            horizontalalignment="right",
            verticalalignment="center",
            transform=newax.transAxes,
        )
        newax.text(
            text_x,
            text_y,
            "%2.1f%%" % bad,
            color="tomato",
            weight=1000,
            size=25,
            horizontalalignment="right",
            verticalalignment="center",
            transform=newax.transAxes,
        )

        newax.text(
            1 - text_x,
            text_y,
            rater_names[i],
            color="k",
            size=25,
            horizontalalignment="left",
            verticalalignment="center",
            transform=newax.transAxes,
        )

    newax.text(
        0.5,
        0.95,
        "Imbalance of ratings",
        color="k",
        size=25,
        horizontalalignment="center",
        verticalalignment="top",
        transform=newax.transAxes,
    )
    newax.text(
        0.5,
        0.85,
        "(ABIDE, aggregated)",
        color="k",
        size=25,
        horizontalalignment="center",
        verticalalignment="top",
        transform=newax.transAxes,
    )

    if out_file is None:
        out_file = "raters.svg"

    fname, ext = op.splitext(out_file)
    if ext[1:] not in ["pdf", "svg", "png"]:
        ext = ".svg"
        out_file = fname + ".svg"

    fig.savefig(
        op.abspath(out_file), format=ext[1:], bbox_inches="tight", pad_inches=0, dpi=300
    )
    return fig


def plot_abide_stripplots(
    inputs, figsize=(15, 2), out_file=None, rating_label="rater_1", dpi=100
):
    import seaborn as sn
    from ..classifier.helper import FEATURE_NORM
    from ..classifier.data import read_dataset
    from ..classifier.sklearn.preprocessing import BatchRobustScaler

    sn.set(style="whitegrid")

    mdata = []
    pp_cols = []

    for X, Y, sitename in inputs:
        sitedata, cols = read_dataset(
            X, Y, rate_label=rating_label, binarize=False, site_name=sitename
        )
        sitedata["database"] = [sitename] * len(sitedata)

        if sitename == "DS030":
            sitedata["site"] = [sitename] * len(sitedata)

        mdata.append(sitedata)
        pp_cols.append(cols)

    mdata = pd.concat(mdata)
    pp_cols = pp_cols[0]

    for col in mdata.columns.ravel().tolist():
        if col.startswith("rater_") and col != rating_label:
            del mdata[col]

    mdata = mdata.loc[mdata[rating_label].notnull()]

    for col in ["size_x", "size_y", "size_z", "spacing_x", "spacing_y", "spacing_z"]:
        del mdata[col]
        try:
            pp_cols.remove(col)
        except ValueError:
            pass

    zscored = BatchRobustScaler(by="site", columns=FEATURE_NORM).fit_transform(mdata)

    sites = list(set(mdata.site.values.ravel()))
    nsites = len(sites)

    # palette = ['dodgerblue', 'darkorange']
    palette = ["limegreen", "tomato"]
    if len(set(mdata[[rating_label]].values.ravel().tolist())) == 3:
        palette = ["tomato", "gold", "limegreen"]
    # pp_cols = pp_cols[:5]
    nrows = len(pp_cols)

    fig = plt.figure(figsize=(figsize[0], figsize[1] * nrows))
    # ncols = 2 * (nsites - 1) + 2
    gs = GridSpec(nrows, 4, wspace=0.02)
    gs.set_width_ratios([nsites, len(inputs), len(inputs), nsites])

    for i, colname in enumerate(pp_cols):
        ax_nzs = plt.subplot(gs[i, 0])
        axg_nzs = plt.subplot(gs[i, 1])
        axg_zsc = plt.subplot(gs[i, 2])
        ax_zsc = plt.subplot(gs[i, 3])

        # plots
        sn.stripplot(
            x="site",
            y=colname,
            data=mdata,
            hue=rating_label,
            jitter=0.18,
            alpha=0.6,
            split=True,
            palette=palette,
            ax=ax_nzs,
        )
        sn.stripplot(
            x="site",
            y=colname,
            data=zscored,
            hue=rating_label,
            jitter=0.18,
            alpha=0.6,
            split=True,
            palette=palette,
            ax=ax_zsc,
        )

        sn.stripplot(
            x="database",
            y=colname,
            data=mdata,
            hue=rating_label,
            jitter=0.18,
            alpha=0.6,
            split=True,
            palette=palette,
            ax=axg_nzs,
        )
        sn.stripplot(
            x="database",
            y=colname,
            data=zscored,
            hue=rating_label,
            jitter=0.18,
            alpha=0.6,
            split=True,
            palette=palette,
            ax=axg_zsc,
        )

        ax_nzs.legend_.remove()
        ax_zsc.legend_.remove()
        axg_nzs.legend_.remove()
        axg_zsc.legend_.remove()

        if i == nrows - 1:
            ax_nzs.set_xticklabels(ax_nzs.xaxis.get_majorticklabels(), rotation=80)
            ax_zsc.set_xticklabels(ax_zsc.xaxis.get_majorticklabels(), rotation=80)
            axg_nzs.set_xticklabels(axg_nzs.xaxis.get_majorticklabels(), rotation=80)
            axg_zsc.set_xticklabels(axg_zsc.xaxis.get_majorticklabels(), rotation=80)
        else:
            ax_nzs.set_xticklabels([])
            ax_zsc.set_xticklabels([])
            axg_nzs.set_xticklabels([])
            axg_zsc.set_xticklabels([])

        ax_nzs.set_xlabel("", visible=False)
        ax_zsc.set_xlabel("", visible=False)
        ax_zsc.set_ylabel("", visible=False)
        ax_zsc.yaxis.tick_right()

        axg_nzs.set_yticklabels([])
        axg_nzs.set_xlabel("", visible=False)
        axg_nzs.set_ylabel("", visible=False)
        axg_zsc.set_yticklabels([])
        axg_zsc.set_xlabel("", visible=False)
        axg_zsc.set_ylabel("", visible=False)

        for yt in ax_nzs.yaxis.get_major_ticks()[1:-1]:
            yt.label1.set_visible(False)

        for yt in axg_nzs.yaxis.get_major_ticks()[1:-1]:
            yt.label1.set_visible(False)

        for yt in zip(
            ax_zsc.yaxis.get_majorticklabels(), axg_zsc.yaxis.get_majorticklabels()
        ):
            yt[0].set_visible(False)
            yt[1].set_visible(False)

    if out_file is None:
        out_file = "stripplot.svg"

    fname, ext = op.splitext(out_file)
    if ext[1:] not in ["pdf", "svg", "png"]:
        ext = ".svg"
        out_file = fname + ".svg"

    fig.savefig(
        op.abspath(out_file), format=ext[1:], bbox_inches="tight", pad_inches=0, dpi=dpi
    )
    return fig


def plot_corrmat(in_csv, out_file=None):
    import seaborn as sn

    sn.set(style="whitegrid")

    dataframe = pd.read_csv(in_csv, index_col=False, na_values="n/a", na_filter=False)
    colnames = dataframe.columns.ravel().tolist()

    for col in ["subject_id", "site", "modality"]:
        try:
            colnames.remove(col)
        except ValueError:
            pass

    # Correlation matrix
    corr = dataframe[colnames].corr()
    corr = corr.dropna((0, 1), "all")

    # Generate a mask for the upper triangle
    mask = np.zeros_like(corr, dtype=np.bool)
    mask[np.triu_indices_from(mask)] = True

    # Generate a custom diverging colormap
    cmap = sn.diverging_palette(220, 10, as_cmap=True)

    # Draw the heatmap with the mask and correct aspect ratio
    corrplot = sn.clustermap(
        corr, cmap=cmap, center=0.0, method="average", square=True, linewidths=0.5
    )
    plt.setp(corrplot.ax_heatmap.yaxis.get_ticklabels(), rotation="horizontal")
    # , mask=mask, square=True, linewidths=.5, cbar_kws={"shrink": .5})

    if out_file is None:
        out_file = "corr_matrix.svg"

    fname, ext = op.splitext(out_file)
    if ext[1:] not in ["pdf", "svg", "png"]:
        ext = ".svg"
        out_file = fname + ".svg"

    corrplot.savefig(
        out_file, format=ext[1:], bbox_inches="tight", pad_inches=0, dpi=100
    )
    return corrplot


def plot_histograms(X, Y, rating_label="rater_1", out_file=None):
    import re
    import seaborn as sn
    from ..classifier.data import read_dataset

    sn.set(style="whitegrid")

    mdata, pp_cols = read_dataset(X, Y, rate_label=rating_label)
    mdata["rater"] = mdata[[rating_label]].values.ravel()

    for col in mdata.columns.ravel().tolist():
        if col.startswith("rater_"):
            del mdata[col]

    mdata = mdata.loc[mdata.rater.notnull()]
    zscored = mdata.copy()
    # TODO: zscore_dataset was removed
    # zscored = zscore_dataset(
    #     mdata, excl_columns=['rater', 'size_x', 'size_y', 'size_z',
    #                          'spacing_x', 'spacing_y', 'spacing_z'])
    pat = re.compile(r"^(spacing|summary|size)")
    colnames = [col for col in sorted(pp_cols) if pat.match(col)]

    nrows = len(colnames)
    # palette = ['dodgerblue', 'darkorange']

    fig = plt.figure(figsize=(18, 2 * nrows))
    gs = GridSpec(nrows, 2, hspace=0.2)

    for i, col in enumerate(sorted(colnames)):
        ax_nzs = plt.subplot(gs[i, 0])
        ax_zsd = plt.subplot(gs[i, 1])

        sn.distplot(
            mdata.loc[(mdata.rater == 0), col],
            norm_hist=False,
            label="Accept",
            ax=ax_nzs,
            color="dodgerblue",
        )
        sn.distplot(
            mdata.loc[(mdata.rater == 1), col],
            norm_hist=False,
            label="Reject",
            ax=ax_nzs,
            color="darkorange",
        )
        ax_nzs.legend()

        sn.distplot(
            zscored.loc[(zscored.rater == 0), col],
            norm_hist=False,
            label="Accept",
            ax=ax_zsd,
            color="dodgerblue",
        )
        sn.distplot(
            zscored.loc[(zscored.rater == 1), col],
            norm_hist=False,
            label="Reject",
            ax=ax_zsd,
            color="darkorange",
        )

        alldata = mdata[[col]].values.ravel().tolist()
        minv = np.percentile(alldata, 0.2)
        maxv = np.percentile(alldata, 99.8)
        ax_nzs.set_xlim([minv, maxv])

        alldata = zscored[[col]].values.ravel().tolist()
        minv = np.percentile(alldata, 0.2)
        maxv = np.percentile(alldata, 99.8)
        ax_zsd.set_xlim([minv, maxv])

    if out_file is None:
        out_file = "histograms.svg"

    fname, ext = op.splitext(out_file)
    if ext[1:] not in ["pdf", "svg", "png"]:
        ext = ".svg"
        out_file = fname + ".svg"

    fig.savefig(out_file, format=ext[1:], bbox_inches="tight", pad_inches=0, dpi=100)
    return fig


def inter_rater_variability(
    y1, y2, figsize=(4, 4), normed=True, raters=None, labels=None, out_file=None
):
    plt.rcParams["font.family"] = "sans-serif"
    plt.rcParams["font.sans-serif"] = "FreeSans"
    plt.rcParams["font.size"] = 25
    plt.rcParams["axes.labelsize"] = 20
    plt.rcParams["axes.titlesize"] = 25
    plt.rcParams["xtick.labelsize"] = 15
    plt.rcParams["ytick.labelsize"] = 15
    # fig = plt.figure(figsize=(3.5, 3))

    if raters is None:
        raters = ["Rater 1", "Rater 2"]

    if labels is None:
        labels = ["exclude", "doubtful", "accept"]

    fig, ax = plt.subplots(figsize=figsize)
    ax.set_aspect("equal")

    nbins = len(set(y1 + y2))
    if nbins == 2:
        xlabels = [labels[0], labels[-1]]
        ylabels = [labels[0], labels[-1]]

    # Reverse x
    y1 = (np.array(y1) * -1).tolist()
    ylabels = labels
    xlabels = list(reversed(labels))

    hist, xbins, ybins, _ = plt.hist2d(y1, y2, bins=nbins, cmap=plt.cm.viridis)
    xcenters = (xbins[:-1] + xbins[1:]) * 0.5
    ycenters = (ybins[:-1] + ybins[1:]) * 0.5

    total = np.sum(hist.reshape(-1))
    celfmt = "%d%%" if normed else "%d"
    for i, x in enumerate(xcenters):
        for j, y in enumerate(ycenters):
            val = hist[i, j]
            if normed:
                val = 100 * hist[i, j] / total

            ax.text(
                x,
                y,
                celfmt % val,
                ha="center",
                va="center",
                fontweight="bold",
                color="w" if hist[i, j] < 15 else "k",
            )

    # plt.colorbar(pad=0.10)
    plt.grid(False)
    plt.xticks(xcenters, xlabels)
    plt.yticks(ycenters, ylabels, rotation="vertical", va="center")
    plt.xlabel(raters[0])
    plt.ylabel(raters[1])
    ax.yaxis.tick_right()
    ax.xaxis.set_label_position("top")

    if out_file is not None:
        fig.savefig(out_file, bbox_inches="tight", pad_inches=0, dpi=300)

    return fig


def plot_artifact(
    image_path,
    figsize=(20, 20),
    vmax=None,
    cut_coords=None,
    display_mode="ortho",
    size=None,
):
    import nilearn.plotting as nplt

    fig = plt.figure(figsize=figsize)
    nplt_disp = nplt.plot_anat(
        image_path,
        display_mode=display_mode,
        cut_coords=cut_coords,
        vmax=vmax,
        figure=fig,
        annotate=False,
    )

    if size is None:
        size = figsize[0] * 6

    bg_color = "k"
    fg_color = "w"
    ax = fig.gca()
    ax.text(
        0.1,
        0.95,
        "L",
        transform=ax.transAxes,
        horizontalalignment="left",
        verticalalignment="top",
        size=size,
        bbox=dict(boxstyle="square,pad=0", ec=bg_color, fc=bg_color, alpha=1),
        color=fg_color,
    )

    ax.text(
        0.9,
        0.95,
        "R",
        transform=ax.transAxes,
        horizontalalignment="right",
        verticalalignment="top",
        size=size,
        bbox=dict(boxstyle="square,pad=0", ec=bg_color, fc=bg_color),
        color=fg_color,
    )

    return nplt_disp, ax


def figure1_a(
    image_path, display_mode="y", vmax=300, cut_coords=None, figsize=(20, 20)
):
    import matplotlib.patches as patches

    if cut_coords is None:
        cut_coords = [15]

    disp, ax = plot_artifact(
        image_path,
        display_mode=display_mode,
        vmax=vmax,
        cut_coords=cut_coords,
        figsize=figsize,
    )

    ax.add_patch(
        patches.Arrow(
            0.2,  # x
            0.2,  # y
            0.1,  # dx
            0.6,  # dy
            width=0.25,
            color="tomato",
            transform=ax.transAxes,
        )
    )

    ax.add_patch(
        patches.Arrow(
            0.8,  # x
            0.2,  # y
            -0.1,  # dx
            0.6,  # dy
            width=0.25,
            color="tomato",
            transform=ax.transAxes,
        )
    )
    return disp


def figure1_b(
    image_path, display_mode="z", vmax=400, cut_coords=None, figsize=(20, 20)
):
    import matplotlib.patches as patches

    if cut_coords is None:
        cut_coords = [-24]

    disp, ax = plot_artifact(
        image_path,
        display_mode=display_mode,
        vmax=vmax,
        cut_coords=cut_coords,
        figsize=figsize,
    )

    ax.add_patch(
        patches.Arrow(
            0.02,  # x
            0.55,  # y
            0.1,  # dx
            0.0,  # dy
            width=0.10,
            color="tomato",
            transform=ax.transAxes,
        )
    )
    ax.add_patch(
        patches.Arrow(
            0.98,  # x
            0.55,  # y
            -0.1,  # dx
            0.0,  # dy
            width=0.10,
            color="tomato",
            transform=ax.transAxes,
        )
    )

    ax.add_patch(
        patches.Arrow(
            0.02,  # x
            0.80,  # y
            0.1,  # dx
            0.0,  # dy
            width=0.10,
            color="limegreen",
            transform=ax.transAxes,
        )
    )
    ax.add_patch(
        patches.Arrow(
            0.98,  # x
            0.80,  # y
            -0.1,  # dx
            0.0,  # dy
            width=0.10,
            color="limegreen",
            transform=ax.transAxes,
        )
    )
    return disp


def figure1(artifact1, artifact2, out_file):
    from .svg import svg2str, combine_svg

    combine_svg(
        [svg2str(figure1_b(artifact2)), svg2str(figure1_a(artifact1))], axis="vertical"
    ).save(out_file)
