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

from dos_input import *


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]])

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


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': 'isolated.inp',
                    'molec_file': 'acetic.xyz',
                    'cluster_magns': ['energy', 'moi'],
                    'num_conformers': 100,
                    'min_confs': False,
                    'screen_inp_file': 'screen.inp',
                    'sites': [128, [135, 138, 141]],
                    'molec_ads_ctrs': [178, [185, 187]],
                    'try_disso': True,
                    'sample_points_per_angle': 4,
                    'collision_threshold': 0.9,
                    'collision_bottom_z': 5.2,
                    'refine_inp_file': 'refine.inp',
                    'energy_cutoff': 1.0
                    }
        self.assertEqual(read_input('good.inp'), exp_dict)

    # TODO add single tests for subm_script and project_name

    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_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(), 'isolated.inp')

    def test_molec_file(self):
        print(os.getcwd())
        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_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_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_z(self):
        self.assertEqual(get_coll_bottom_z(), 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_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_sites(self):
        self.assertRaises(ValueError, get_sites)

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

    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_z(self):
        self.assertRaises(ValueError, get_coll_bottom_z)

    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()