import sys
import unittest
import numpy as np
from modules.dos_input import *

sys.path.extend(['../', '../modules', '../examples'])


class TestStr2Lst(unittest.TestCase):
    def test_norm_behav(self):
        self.assertEqual(str2lst('45'), [45])
        self.assertEqual(str2lst('(78, 9)'), [[78, 9]])
        self.assertEqual(str2lst('128,(135 138;141) 87 {45 68}'),
                         [128, 87, [135, 138, 141], [45, 68]])
        self.assertEqual(str2lst('3 4.5', float), [3.0, 4.5])

    def test_exceptions(self):
        self.assertRaises(AttributeError, str2lst, 6)
        self.assertRaises(ValueError, str2lst, 'hola')
        self.assertRaises(ValueError, str2lst, '3 ((6 7) 8) 4')
        self.assertRaises(ValueError, str2lst, '3 4.5')


class TestCheckInpFile(unittest.TestCase):
    def test_good(self):
        self.assertEqual(check_inp_file('cp2k.inp', 'cp2k'), None)

    def test_bad(self):
        self.assertRaises(UnboundLocalError, check_inp_file, 'cp2k.sub', 'cp2k')


class TestGoodInput(unittest.TestCase):
    read_input('good.inp')

    def test_all_good(self):
        exp_dict = {'project_name': 'example',
                    'isolated': True,
                    'screening': True,
                    'refinement': True,
                    'code': 'cp2k',
                    'batch_q_sys': 'sge',
                    'subm_script': 'cp2k.sub',
                    'relaunch_err': 'geo_not_conv',
                    'max_qw': 5,
                    'special_atoms': [('Fe1', 'Fe'), ('Fe2', 'Fe'),
                                      ('O1', 'O')],
                    'isol_inp_file': 'cp2k.inp',
                    'molec_file': 'acetic.xyz',
                    'cluster_magns': ['energy', 'moi'],
                    'num_conformers': 100,
                    'min_confs': False,
                    'screen_inp_file': 'screen.inp',
                    'surf_file': 'hematite.xyz',
                    'sites': [128, [135, 138, 141]],
                    'molec_ads_ctrs': [178, [185, 187]],
                    'molec_neigh_ctrs': [145, 45],
                    'surf_norm_vect': np.array([1.0, 0.0, 0.0]),
                    'try_disso': True,
                    'sample_points_per_angle': 4,
                    'collision_threshold': 0.9,
                    'min_coll_height': 5.2,
                    'refine_inp_file': 'refine.inp',
                    'energy_cutoff': 1.0
                    }
        self.assertEqual(read_input('good.inp'), exp_dict)

    def test_run_type(self):
        self.assertEqual(get_run_type(), (True, True, True))

    def test_code(self):
        self.assertEqual(get_code(), 'cp2k')

    def test_batch_q_sys(self):
        self.assertEqual(get_batch_q_sys(), 'sge')

    def test_subm_script(self):
        self.assertEqual(get_subm_script(), 'cp2k.sub')

    def test_project_name(self):
        self.assertEqual(get_project_name(), 'example')

    def test_relaunch_err(self):
        self.assertEqual(get_relaunch_err(), 'geo_not_conv')

    def test_max_qw(self):
        self.assertEqual(get_max_qw(), 5)

    def test_special_atoms(self):
        self.assertEqual(get_special_atoms(), [('Fe1', 'Fe'), ('Fe2', 'Fe'),
                                               ('O1', 'O')])

    def test_isol_inp_file(self):
        self.assertEqual(get_isol_inp_file(), 'cp2k.inp')

    def test_molec_file(self):
        self.assertEqual(get_molec_file(), 'acetic.xyz')

    def test_cluster_magns(self):
        self.assertEqual(get_cluster_magns(), ['energy', 'moi'])

    def test_num_conformers(self):
        self.assertEqual(get_num_conformers(), 100)

    def test_min_confs(self):
        self.assertEqual(get_min_confs(), False)

    def test_screen_inp_file(self):
        self.assertEqual(get_screen_inp_file(), 'screen.inp')

    def test_surf_file(self):
        self.assertEqual(get_surf_file(), 'hematite.xyz')

    def test_sites(self):
        self.assertEqual(get_sites(), [128, [135, 138, 141]])

    def test_molec_ads_ctrs(self):
        self.assertEqual(get_molec_ads_ctrs(), [178, [185, 187]])

    def test_molec_neigh_ctrs(self):
        self.assertEqual(get_molec_neigh_ctrs(), [145, 45])

    def test_surf_norm_vect(self):
        self.assertEqual(get_surf_norm_vect(), np.array([1.0, 0.0, 0.0]))

    def test_try_disso(self):
        self.assertEqual(get_try_disso(), True)

    def test_pts_per_angle(self):
        self.assertEqual(get_pts_per_angle(), 4)

    def test_coll_thrsld(self):
        self.assertEqual(get_coll_thrsld(), 0.9)

    def test_coll_bottom(self):
        self.assertEqual(get_min_coll_height(), 5.2)

    def test_refine_inp_file(self):
        self.assertEqual(get_refine_inp_file(), 'refine.inp')

    def test_energy_cutoff(self):
        self.assertEqual(get_energy_cutoff(), 1.0)


class TestBadInput(unittest.TestCase):
    dos_inp.read('wrong.inp')

    def test_run_type(self):
        self.assertRaises(ValueError, get_run_type)

    def test_code(self):
        self.assertRaises(ValueError, get_code)

    def test_batch_q_sys(self):
        self.assertRaises(ValueError, get_batch_q_sys)

    def test_subm_script(self):
        self.assertRaises(FileNotFoundError, get_subm_script)

    def test_relaunch_err(self):
        self.assertRaises(ValueError, get_relaunch_err)

    def test_max_qw(self):
        self.assertRaises(ValueError, get_max_qw)

    def test_special_atoms(self):
        self.assertRaises(ValueError, get_special_atoms)

    def test_isol_inp_file(self):
        self.assertRaises(FileNotFoundError, get_isol_inp_file)

    def test_cluster_magns(self):
        self.assertRaises(ValueError, get_cluster_magns)

    def test_num_conformers(self):
        self.assertRaises(ValueError, get_num_conformers)

    def test_min_confs(self):
        self.assertRaises(ValueError, get_min_confs)

    def test_screen_inp_file(self):
        self.assertRaises(FileNotFoundError, get_screen_inp_file)

    def test_surf_file(self):
        self.assertRaises(FileNotFoundError, get_surf_file)

    def test_sites(self):
        self.assertRaises(ValueError, get_sites)

    def test_molec_ads_ctrs(self):
        self.assertRaises(ValueError, get_molec_ads_ctrs)

    def test_molec_neigh_ctrs(self):
        self.assertRaises(ValueError, get_molec_neigh_ctrs)

    def test_surf_norm_vect(self):
        self.assertRaises(ValueError, get_surf_norm_vect)

    def test_try_disso(self):
        self.assertRaises(ValueError, get_try_disso)

    def test_pts_per_angle(self):
        self.assertRaises(ValueError, get_pts_per_angle)

    def test_coll_thrsld(self):
        self.assertRaises(ValueError, get_coll_thrsld)

    def test_coll_bottom(self):
        self.assertRaises(ValueError, get_min_coll_height)

    def test_refine_inp_file(self):
        self.assertRaises(FileNotFoundError, get_refine_inp_file)

    def test_energy_cutoff(self):
        self.assertRaises(ValueError, get_energy_cutoff)


if __name__ == '__main__':
    unittest.main()
