#!/usr/bin/python

import os
import io
import shutil
from typing import Optional
import requests
import hashlib
import math
import multiprocessing as mp
import json
import re
import tarfile
import resource

rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
resource.setrlimit(resource.RLIMIT_NOFILE, (1 << 16, rlimit[1]))

from ase.io import read
import numpy as np
import torch
import h5py
from materials_toolkit.data import HDF5Dataset
from materials_toolkit.data.datasets import MaterialsProjectData

zip_file = "mp.2019.04.01.json.zip"
url = "https://figshare.com/ndownloader/articles/8097992/versions/2"


def download_raw_mp(path: Optional[str] = "."):
    filename = os.path.join(path, zip_file)

    sha1 = hashlib.sha1()

    if os.path.exists(filename):
        with open(filename, "rb") as f:
            while True:
                data = f.read(1 << 20)
                if not data:
                    break
                sha1.update(data)
        return sha1.hexdigest()

    r = requests.get(url, stream=True)

    with open(zip_file, "wb") as f:
        total_length = int(r.headers.get("content-length"))
        for i, chunk in enumerate(r.iter_content(chunk_size=1 << 20)):
            if chunk:
                sha1.update(chunk)
                f.write(chunk)
                f.flush()
                print(
                    f"[{i+1}/{int(math.ceil(total_length/(1<<20)))}] downloading {zip_file} ..."
                )


def unzip(path: Optional[str] = "."):
    temp_dir = os.path.join(path, "unzipped")

    os.makedirs(temp_dir, exist_ok=True)

    if not os.path.exists(os.path.join(temp_dir, "mp.2019.04.01.json.zip")):
        print("unzip mp.2019.04.01.json.zip")
        shutil.unpack_archive(zip_file, temp_dir)

    if not os.path.exists(os.path.join(temp_dir, "mp.2019.04.01.json")):
        print("unzip mp.2019.04.01.json")
        shutil.unpack_archive(
            os.path.join(temp_dir, "mp.2019.04.01.json.zip"),
            temp_dir,
        )


def gen_structure_from_json(filename: str, chunksize: Optional[int] = 1 << 20):
    stack = None
    with open(filename, "r") as fp:
        count = 0
        fp.seek(0, os.SEEK_END)
        total = int(math.ceil(fp.tell() / chunksize))
        fp.seek(0, os.SEEK_SET)

        while True:
            data = fp.read(chunksize)

            print(f"[{count}/{total}] processing {filename} ...")
            count += 1

            if len(data) == 0:
                break

            if stack is None:
                stack = data[data.find("{") + 1 :]
            else:
                stack += data

            splited = re.split(r"}\s*,\s*{", stack)
            for elem in splited[:-1]:
                yield "{" + elem + "}"

            stack = splited[-1]

    stack = stack[: stack.rfind("}")]
    yield "{" + stack + "}"


def parse_structure(json_str: str) -> MaterialsProjectData:
    data = json.loads(json_str)
    struct = read(io.StringIO(data["structure"]), format="cif")

    cell = torch.from_numpy(struct.cell.array).unsqueeze(0).float()
    x = torch.from_numpy(struct.get_scaled_positions()).float()
    z = torch.from_numpy(struct.get_atomic_numbers()).int()
    material_id = torch.tensor(
        [int(data["material_id"].split("-")[1])], dtype=torch.long
    )
    energy_pa = torch.tensor([data["formation_energy_per_atom"]], dtype=torch.float)

    return MaterialsProjectData(
        pos=x, z=z, cell=cell, material_id=material_id, energy_pa=energy_pa
    )


def process(path: Optional[str] = "."):
    mp_dir = os.path.join(path, "materials-project")
    processed_dir = os.path.join(mp_dir, "processed")

    os.makedirs(processed_dir, exist_ok=True)

    if (not os.path.exists(os.path.join(processed_dir, "batching.json"))) or not (
        os.path.exists(os.path.join(processed_dir, "data.hdf5"))
    ):
        results = [
            parse_structure(elem)
            for elem in gen_structure_from_json(
                os.path.join(path, "unzipped/mp.2019.04.01.json")
            )
        ]

        HDF5Dataset.create_dataset(processed_dir, results)

    dataset = HDF5Dataset(mp_dir)
    dataset.compute_convex_hulls()


def compress(path: Optional[str] = "."):
    output_file = os.path.join(path, "materials-project.tar.gz")

    if os.path.exists(output_file):
        return

    print("compress into materials-project.tar.gz")
    with tarfile.open(output_file, "w:gz") as tar:
        tar.add(
            os.path.join(path, "materials-project/processed/batching.json"),
            "batching.json",
        )
        tar.add(
            os.path.join(path, "materials-project/processed/data.hdf5"), "data.hdf5"
        )


download_raw_mp()
unzip()
process()
compress()