# coding: utf8


import numpy as np

from clinica.pipelines.machine_learning import algorithm, base, input, validation


class VoxelBasedKFoldDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        output_dir,
        fwhm=0,
        modulated="on",
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        precomputed_kernel=None,
        mask_zeros=True,
        n_threads=15,
        n_folds=10,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(VoxelBasedKFoldDualSVM, self).__init__(
            input.CAPSVoxelBasedInput,
            validation.KFoldCV,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class VoxelBasedRepKFoldDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        output_dir,
        fwhm=0,
        modulated="on",
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        precomputed_kernel=None,
        mask_zeros=True,
        n_threads=15,
        n_iterations=100,
        n_folds=10,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(VoxelBasedRepKFoldDualSVM, self).__init__(
            input.CAPSVoxelBasedInput,
            validation.RepeatedKFoldCV,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class VoxelBasedRepHoldOutDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        output_dir,
        fwhm=0,
        modulated="on",
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        precomputed_kernel=None,
        mask_zeros=True,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super().__init__(
            input.CAPSVoxelBasedInput,
            validation.RepeatedHoldOut,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class VertexBasedRepHoldOutDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        output_dir,
        image_type="PET",
        acq_label=None,
        suvr_reference_region=None,
        fwhm=20,
        precomputed_kernel=None,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-10, 2, 1000),
        splits_indices=None,
    ):

        super(VertexBasedRepHoldOutDualSVM, self).__init__(
            input.CAPSVertexBasedInput,
            validation.RepeatedHoldOut,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class RegionBasedRepHoldOutDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        output_dir,
        use_pvc_data=False,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(RegionBasedRepHoldOutDualSVM, self).__init__(
            input.CAPSRegionBasedInput,
            validation.RepeatedHoldOut,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class RegionBasedRepHoldOutLogisticRegression(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        output_dir,
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(RegionBasedRepHoldOutLogisticRegression, self).__init__(
            input.CAPSRegionBasedInput,
            validation.RepeatedHoldOut,
            algorithm.LogisticReg,
            locals(),
            output_dir,
        )


class RegionBasedRepHoldOutRandomForest(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        output_dir,
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        n_estimators_range=(100, 200, 400),
        max_depth_range=[None],
        min_samples_split_range=[2],
        max_features_range=("auto", 0.25, 0.5),
        splits_indices=None,
    ):

        super(RegionBasedRepHoldOutRandomForest, self).__init__(
            input.CAPSRegionBasedInput,
            validation.RepeatedHoldOut,
            algorithm.RandomForest,
            locals(),
            output_dir,
        )


class RegionBasedLearningCurveRepHoldOutDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        output_dir,
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        precomputed_kernel=None,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        n_learning_points=10,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
    ):

        super(RegionBasedLearningCurveRepHoldOutDualSVM, self).__init__(
            input.CAPSRegionBasedInput,
            validation.LearningCurveRepeatedHoldOut,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class VoxelBasedLearningCurveRepHoldOutDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        output_dir,
        fwhm=0,
        modulated="on",
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        precomputed_kernel=None,
        mask_zeros=True,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        n_learning_points=10,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
    ):

        super(VoxelBasedLearningCurveRepHoldOutDualSVM, self).__init__(
            input.CAPSVoxelBasedInput,
            validation.LearningCurveRepeatedHoldOut,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class RegionBasedRepKFoldDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        output_dir,
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        n_folds=10,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(RegionBasedRepKFoldDualSVM, self).__init__(
            input.CAPSRegionBasedInput,
            validation.RepeatedKFoldCV,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class CAPSTsvRepHoldOutDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        dataset,
        output_dir,
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(CAPSTsvRepHoldOutDualSVM, self).__init__(
            input.CAPSTSVBasedInput,
            validation.RepeatedHoldOut,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


class CAPSTsvRepHoldOutRandomForest(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        atlas,
        dataset,
        output_dir,
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        n_threads=15,
        n_iterations=100,
        test_size=0.3,
        grid_search_folds=10,
        balanced=True,
        n_estimators_range=(100, 200, 400),
        max_depth_range=[None],
        min_samples_split_range=[2],
        max_features_range=("auto", 0.25, 0.5),
        splits_indices=None,
    ):

        super(CAPSTsvRepHoldOutRandomForest, self).__init__(
            input.CAPSTSVBasedInput,
            validation.RepeatedHoldOut,
            algorithm.RandomForest,
            locals(),
            output_dir,
        )


# SVM reg


class VoxelBasedREGRepKFoldDualSVM(base.MLWorkflow):
    def __init__(
        self,
        caps_directory,
        subjects_visits_tsv,
        diagnoses_tsv,
        group_label,
        image_type,
        output_dir,
        fwhm=0,
        modulated="on",
        acq_label=None,
        suvr_reference_region=None,
        use_pvc_data=False,
        precomputed_kernel=None,
        mask_zeros=True,
        n_threads=15,
        n_iterations=100,
        n_folds=10,
        test_size=0.1,
        grid_search_folds=10,
        balanced=True,
        c_range=np.logspace(-6, 2, 17),
        splits_indices=None,
    ):

        super(VoxelBasedREGRepKFoldDualSVM, self).__init__(
            input.CAPSTSVBasedInput,
            validation.RepeatedKFoldCV,
            algorithm.DualSVMAlgorithm,
            locals(),
            output_dir,
        )


# TSV


class TsvRepHoldOutRandomForest(base.MLWorkflow):
    def __init__(
        self,
        data_tsv,
        columns,
        output_dir,
        n_threads=20,
        n_iterations=250,
        test_size=0.2,
        grid_search_folds=10,
        balanced=True,
        n_estimators_range=(100, 200, 400),
        max_depth_range=[None],
        min_samples_split_range=[2],
        max_features_range=("auto", 0.25, 0.5),
        splits_indices=None,
        inner_cv=False,
    ):

        super(TsvRepHoldOutRandomForest, self).__init__(
            input.TsvInput,
            validation.RepeatedHoldOut,
            algorithm.RandomForest,
            locals(),
            output_dir,
        )
