"""Module for the interconversion between different kinds of atomic data.

functions:
confs_to_mol_list: Converts the conformers inside a rdkit.Mol object to a list
    of separate rdkit.Mol objects.
rdkit_mol_to_ase_atoms: Converts a rdkit.Mol object into ase.Atoms object.
add_special_atoms: Allows ase to use custom elements with symbols not in the
    periodic table.
adapt_format: Converts the coordinate files into a required library object type.
read_coords_cp2k: Reads the coordinates from a CP2K restart file and returns an
    ase.Atoms object.
collect_coords: Directs the reading of coordinates on a set of subdirectories.
read_energy_cp2k: Reads the CP2K out file and returns its final energy.
collect_energies: Directs the reading of energies on a set of subdirectories.
"""

import logging

import rdkit.Chem.AllChem as Chem

logger = logging.getLogger('DockOnSurf')


def confs_to_mol_list(mol: Chem.rdchem.Mol, idx_lst=None):
    """Converts the conformers inside a rdkit mol object to a list of
    separate mol objects.

    @param mol: rdkit mol object containing at least one conformer.
    @param idx_lst: list of conformer indices to be considered. If not passed,
        all conformers are considered.
    @return: list of separate mol objects.
    """
    if idx_lst is None:
        idx_lst = list(range(mol.GetNumConformers()))
    return [Chem.MolFromMolBlock(
        Chem.MolToMolBlock(mol, confId=int(idx)).replace("3D", ""),
        removeHs=False) for idx in idx_lst]


def rdkit_mol_to_ase_atoms(mol: Chem.rdchem.Mol):
    """Converts a rdkit mol object into ase Atoms object.
    @param mol: rdkit mol object containing only one conformer.
    @return ase.Atoms: ase Atoms object with the same coordinates.
    """
    from ase import Atoms
    if mol.GetNumConformers() > 1:
        logger.warning('A mol object with multiple conformers is parsed, '
                       'converting to Atoms only the first conformer.')
    symbols = [atm.GetSymbol() for atm in mol.GetAtoms()]
    positions = mol.GetConformer(0).GetPositions()
    return Atoms(symbols=symbols, positions=positions)


def add_special_atoms(symbol_pairs):
    """Allows ase to use custom elements with symbols not in the periodic table.

    This function adds new chemical elements to be used by ase. Every new custom
    element must have a traditional (present in the periodic table) partner
    from which to obtain all its properties.
    @param symbol_pairs: List of tuples containing pairs of chemical symbols.
        Every tuple contains a pair of chemical symbols, the first label must be
        the label of the custom element and the second one the symbol of the
        reference one (traditional present on the periodic table).
    @return:
    """  # TODO Enable special atoms for rdkit
    import numpy as np
    from ase import data
    for i, pair in enumerate(symbol_pairs):
        data.chemical_symbols += [pair[0]]
        z_orig = data.atomic_numbers[pair[1]]
        orig_iupac_mass = data.atomic_masses_iupac2016[z_orig]
        orig_com_mass = data.atomic_masses_common[z_orig]
        data.atomic_numbers[pair[0]] = max(data.atomic_numbers.values()) + 1
        data.atomic_names += [pair[0]]
        data.atomic_masses_iupac2016 = np.append(data.atomic_masses_iupac2016,
                                                 orig_iupac_mass)
        data.atomic_masses = data.atomic_masses_iupac2016
        data.atomic_masses_common = np.append(data.atomic_masses_common,
                                              orig_com_mass)
        data.covalent_radii = np.append(data.covalent_radii,
                                        data.covalent_radii[z_orig])
        data.reference_states += [data.reference_states[z_orig]]
        # TODO Add vdw_radii, gsmm and aml (smaller length)


def adapt_format(requirement, coord_file, spec_atms=tuple()):
    """Converts the coordinate files into a required library object type.

    Depending on the library required to use and the file type, it converts the
    coordinate file into a library-workable object.
    @param requirement: str, the library for which the conversion should be
    made. Accepted values: 'ase', 'rdkit'.
    @param coord_file: str, path to the coordinates file aiming to convert.
    Accepted file tyoes: 'xyz', 'mol'.
    @param spec_atms: List of tuples containing pairs of new/traditional
        chemical symbols.
    @return: an object the required library can work with.
    """  # TODO POSCAR/CONTCAR files
    import ase.io
    from ase.io.formats import filetype

    req_vals = ['rdkit', 'ase']
    file_type_vals = ['xyz', 'mol']
    lib_err = f"The conversion to the '{requirement}' library object type" \
              f" has not yet been implemented"
    conv_info = f"Converted {coord_file} to {requirement} object type"

    fil_type_err = f'The {filetype(coord_file)} file formnat is not supported'

    if requirement not in req_vals:
        logger.error(lib_err)
        raise NotImplementedError(lib_err)

    if filetype(coord_file) not in file_type_vals:
        logger.error(fil_type_err)
        raise NotImplementedError(fil_type_err)

    if requirement == 'rdkit':
        if filetype(coord_file) == 'xyz':
            from modules.xyz2mol import xyz2mol
            ase_atms = ase.io.read(coord_file)
            atomic_nums = ase_atms.get_atomic_numbers().tolist()
            xyz_coordinates = ase_atms.positions.tolist()
            rd_mol_obj = xyz2mol(atomic_nums, xyz_coordinates, charge=0)
            logger.debug(conv_info)
            return Chem.AddHs(rd_mol_obj)
        elif filetype(coord_file) == 'mol':
            logger.debug(conv_info)
            return Chem.AddHs(Chem.MolFromMolFile(coord_file, removeHs=False))

    if requirement == 'ase':
        add_special_atoms(spec_atms)
        if filetype(coord_file) == 'xyz':
            logger.debug(conv_info)
            return ase.io.read(coord_file)
        elif filetype(coord_file) == 'mol':
            logger.debug(conv_info)
            rd_mol = Chem.AddHs(Chem.MolFromMolFile(coord_file, removeHs=False))
            return rdkit_mol_to_ase_atoms(rd_mol)


def read_coords_cp2k(file, spec_atoms=tuple()):
    """Reads the coordinates from a CP2K restart file and returns an ase.Atoms
     object.

    @param file: The file to read containing the coordinates.
    @param spec_atoms: List of tuples containing the pairs of chemical symbols.
    @return: ase.Atoms object of the coordinates in the file.
    """
    import numpy as np
    from ase import Atoms
    from pycp2k import CP2K

    cp2k = CP2K()
    cp2k.parse(file)
    force_eval = cp2k.CP2K_INPUT.FORCE_EVAL_list[0]
    raw_coords = force_eval.SUBSYS.COORD.Default_keyword
    symbols = [atom.split()[0] for atom in raw_coords]
    positions = np.array([atom.split()[1:] for atom in raw_coords])
    if len(spec_atoms) > 0:
        add_special_atoms(spec_atoms)  # TODO check usage
    return Atoms(symbols=symbols, positions=positions)


def collect_coords(conf_list, code, run_type, spec_atms=tuple()):
    """Directs the reading of coordinates on a set of subdirectories.

    Given a dockonsurf directory hierarchy: project/run_type/conf_X
    (run_type = ['isolated', 'screening' or 'refinement']) with finished
    calculations produced by a given code, stored in every conf_X subdirectory,
    it collects the coordinates of the specified conf_X subdirectories in a
    single run_type by calling the adequate function (depending on the code) and
    returns a list of ase.Atoms objects.

    @param conf_list: List of directories where to read the coords from.
    @param code: the code that produced the calculation results files.
    @param run_type: the type of calculation (and also the name of the folder)
                     containing the calculation subdirectories.
    @param spec_atms: List of tuples containing pairs of new/traditional
        chemical symbols.
    @return: list of ase.Atoms objects.
    """
    from glob import glob
    atoms_list = []
    for conf in conf_list:
        if code == 'cp2k':
            atoms_list.append(read_coords_cp2k(glob(f"{run_type}/{conf}/*-1"
                                                    f".restart")[0], spec_atms))
        # elif code == 'vasp'
    return atoms_list


def read_energy_cp2k(file):
    """Reads the CP2K out file and returns its final energy.

    @param file: The file from which the energy should be read.
    @return: The last energy on the out file.
    """
    out_fh = open(file, 'r')
    energy = None
    for line in out_fh:
        if "ENERGY| Total FORCE_EVAL ( QS ) energy (a.u.):" in line:
            energy = float(line.strip().split(':')[1]) * 27.2113845  # Ha to eV
    out_fh.close()
    return energy


def collect_energies(conf_list, code, run_type):
    """Directs the reading of energies on a set of subdirectories.

    Given a dockonsurf directory hierarchy: project/run_type/conf_X
    (run_type = ['isolated', 'screening' or 'refinement']) with finished
    calculations produced by a given code, stored in every conf_X subdirectory,
    it collects the energies of the specified conf_X subdirectories in a
    single run_type by calling the adequate function (depending on the code) and
    returns a list of energies.

    @param conf_list: List of directories where to read the energy.
    @param code: The code that produced the calculation output files.
    @param run_type: The type of calculation (and also the name of the folder)
                     containing the calculation subdirectories.
    @return: List of energies
    """
    from glob import glob
    import numpy as np

    energies = []
    for conf in conf_list:
        if code == 'cp2k':
            energies.append(read_energy_cp2k(
                glob(f"{run_type}/{conf}/*.out")[0]))

    if len(energies) == 0:
        err = f"No results found on {run_type}"
        logger.error(err)
        raise FileNotFoundError(err)

    return np.array(energies)