# -*- coding: utf-8 -*-
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
import os
import os.path as op
import pytest
from nipype.testing.fixtures import (
    create_files_in_directory_plus_dummy_file,
    create_surf_file_in_directory,
)

from nipype.pipeline import engine as pe
from nipype.interfaces import freesurfer as fs
from nipype.interfaces.base import TraitError
from nipype.interfaces.io import FreeSurferSource


@pytest.mark.skipif(fs.no_freesurfer(), reason="freesurfer is not installed")
def test_sample2surf(create_files_in_directory_plus_dummy_file):

    s2s = fs.SampleToSurface()
    # Test underlying command
    assert s2s.cmd == "mri_vol2surf"

    # Test mandatory args exception
    with pytest.raises(ValueError):
        s2s.run()

    # Create testing files
    files, cwd = create_files_in_directory_plus_dummy_file

    # Test input settings
    s2s.inputs.source_file = files[0]
    s2s.inputs.reference_file = files[1]
    s2s.inputs.hemi = "lh"
    s2s.inputs.reg_file = files[2]
    s2s.inputs.sampling_range = 0.5
    s2s.inputs.sampling_units = "frac"
    s2s.inputs.sampling_method = "point"

    # Test a basic command line
    assert s2s.cmdline == (
        "mri_vol2surf "
        "--hemi lh --o %s --ref %s --reg reg.dat --projfrac 0.500 --mov %s"
        % (os.path.join(cwd, "lh.a.mgz"), files[1], files[0])
    )

    # Test identity
    s2sish = fs.SampleToSurface(
        source_file=files[1], reference_file=files[0], hemi="rh"
    )
    assert s2s != s2sish

    # Test hits file name creation
    s2s.inputs.hits_file = True
    assert s2s._get_outfilename("hits_file") == os.path.join(cwd, "lh.a_hits.mgz")

    # Test that a 2-tuple range raises an error
    def set_illegal_range():
        s2s.inputs.sampling_range = (0.2, 0.5)

    with pytest.raises(TraitError):
        set_illegal_range()


@pytest.mark.skipif(fs.no_freesurfer(), reason="freesurfer is not installed")
def test_surfsmooth(create_surf_file_in_directory):

    smooth = fs.SurfaceSmooth()

    # Test underlying command
    assert smooth.cmd == "mri_surf2surf"

    # Test mandatory args exception
    with pytest.raises(ValueError):
        smooth.run()

    # Create testing files
    surf, cwd = create_surf_file_in_directory

    # Test input settings
    smooth.inputs.in_file = surf
    smooth.inputs.subject_id = "fsaverage"
    fwhm = 5
    smooth.inputs.fwhm = fwhm
    smooth.inputs.hemi = "lh"

    # Test the command line
    assert smooth.cmdline == (
        "mri_surf2surf --cortex --fwhm 5.0000 --hemi lh --sval %s --tval %s/lh.a_smooth%d.nii --s fsaverage"
        % (surf, cwd, fwhm)
    )

    # Test identity
    shmooth = fs.SurfaceSmooth(
        subject_id="fsaverage",
        fwhm=6,
        in_file=surf,
        hemi="lh",
        out_file="lh.a_smooth.nii",
    )
    assert smooth != shmooth


@pytest.mark.skipif(fs.no_freesurfer(), reason="freesurfer is not installed")
def test_surfxfm(create_surf_file_in_directory):

    xfm = fs.SurfaceTransform()

    # Test underlying command
    assert xfm.cmd == "mri_surf2surf"

    # Test mandatory args exception
    with pytest.raises(ValueError):
        xfm.run()

    # Create testing files
    surf, cwd = create_surf_file_in_directory

    # Test input settings
    xfm.inputs.source_file = surf
    xfm.inputs.source_subject = "my_subject"
    xfm.inputs.target_subject = "fsaverage"
    xfm.inputs.hemi = "lh"

    # Test the command line
    assert xfm.cmdline == (
        "mri_surf2surf --hemi lh --tval %s/lh.a.fsaverage.nii --sval %s --srcsubject my_subject --trgsubject fsaverage"
        % (cwd, surf)
    )

    # Test identity
    xfmish = fs.SurfaceTransform(
        source_subject="fsaverage",
        target_subject="my_subject",
        source_file=surf,
        hemi="lh",
    )
    assert xfm != xfmish


@pytest.mark.skipif(fs.no_freesurfer(), reason="freesurfer is not installed")
def test_surfshots(create_files_in_directory_plus_dummy_file):

    fotos = fs.SurfaceSnapshots()

    # Test underlying command
    assert fotos.cmd == "tksurfer"

    # Test mandatory args exception
    with pytest.raises(ValueError):
        fotos.run()

    # Create testing files
    files, cwd = create_files_in_directory_plus_dummy_file

    # Test input settins
    fotos.inputs.subject_id = "fsaverage"
    fotos.inputs.hemi = "lh"
    fotos.inputs.surface = "pial"

    # Test a basic command line
    assert fotos.cmdline == "tksurfer fsaverage lh pial -tcl snapshots.tcl"

    # Test identity
    schmotos = fs.SurfaceSnapshots(subject_id="mysubject", hemi="rh", surface="white")
    assert fotos != schmotos

    # Test that the tcl script gets written
    fotos._write_tcl_script()
    assert os.path.exists("snapshots.tcl")

    # Test that we can use a different tcl script
    foo = open("other.tcl", "w").close()
    fotos.inputs.tcl_script = "other.tcl"
    assert fotos.cmdline == "tksurfer fsaverage lh pial -tcl other.tcl"

    # Test that the interface crashes politely if graphics aren't enabled
    try:
        hold_display = os.environ["DISPLAY"]
        del os.environ["DISPLAY"]
        with pytest.raises(RuntimeError):
            fotos.run()
        os.environ["DISPLAY"] = hold_display
    except KeyError:
        pass


@pytest.mark.skipif(fs.no_freesurfer(), reason="freesurfer is not installed")
def test_mrisexpand(tmpdir):
    fssrc = FreeSurferSource(
        subjects_dir=fs.Info.subjectsdir(), subject_id="fsaverage", hemi="lh"
    )

    fsavginfo = fssrc.run().outputs.get()

    # dt=60 to ensure very short runtime
    expand_if = fs.MRIsExpand(
        in_file=fsavginfo["smoothwm"], out_name="expandtmp", distance=1, dt=60
    )

    expand_nd = pe.Node(
        fs.MRIsExpand(
            in_file=fsavginfo["smoothwm"], out_name="expandtmp", distance=1, dt=60
        ),
        name="expand_node",
    )

    # Interfaces should have same command line at instantiation
    orig_cmdline = "mris_expand -T 60 {} 1 expandtmp".format(fsavginfo["smoothwm"])
    assert expand_if.cmdline == orig_cmdline
    assert expand_nd.interface.cmdline == orig_cmdline

    # Run Node interface
    nd_res = expand_nd.run()

    # Commandlines differ
    node_cmdline = (
        "mris_expand -T 60 -pial {cwd}/lh.pial {cwd}/lh.smoothwm "
        "1 expandtmp".format(cwd=nd_res.runtime.cwd)
    )
    assert nd_res.runtime.cmdline == node_cmdline

    # Check output
    if_out_file = expand_if._list_outputs()["out_file"]
    nd_out_file = nd_res.outputs.get()["out_file"]
    # Same filename
    assert op.basename(if_out_file) == op.basename(nd_out_file)
    # Interface places output in source directory
    assert op.dirname(if_out_file) == op.dirname(fsavginfo["smoothwm"])
    # Node places output in working directory
    assert op.dirname(nd_out_file) == nd_res.runtime.cwd


@pytest.mark.skipif(fs.no_freesurfer(), reason="freesurfer is not installed")
def test_eulernumber(tmpdir):
    # grab a surface from fsaverage
    fssrc = FreeSurferSource(
        subjects_dir=fs.Info.subjectsdir(), subject_id="fsaverage", hemi="lh"
    )
    pial = fssrc.run().outputs.pial
    assert isinstance(pial, str), "Problem when fetching surface file"

    eu = fs.EulerNumber()
    eu.inputs.in_file = pial
    res = eu.run()
    assert res.outputs.defects == 0
    assert res.outputs.euler == 2