from contextlib import contextmanager
import math
import multiprocessing
import os
import re
import subprocess

import bpy

import arm.assets as assets
import arm.log as log
import arm.utils

if arm.is_reload(__name__):
    import arm
    assets = arm.reload_module(assets)
    log = arm.reload_module(log)
    arm.utils = arm.reload_module(arm.utils)
else:
    arm.enable_reload(__name__)


def add_irr_assets(output_file_irr):
    assets.add(output_file_irr + '.arm')


def add_rad_assets(output_file_rad, rad_format, num_mips):
    assets.add(output_file_rad + '.' + rad_format)
    for i in range(0, num_mips):
        assets.add(output_file_rad + '_' + str(i) + '.' + rad_format)


@contextmanager
def setup_envmap_render():
    """Creates a background scene for rendering environment textures.
    Use it as a context manager to automatically clean up on errors.
    """
    rpdat = arm.utils.get_rp()
    radiance_size = int(rpdat.arm_radiance_size)

    # Render worlds in a different scene so that there are no other
    # objects. The actual scene might be called differently if the name
    # is already taken
    scene = bpy.data.scenes.new("_arm_envmap_render")
    scene.render.engine = "CYCLES"
    scene.render.image_settings.file_format = "JPEG"
    scene.render.image_settings.quality = 100
    scene.render.resolution_x = radiance_size
    scene.render.resolution_y = radiance_size // 2

    # Set GPU as rendering device if the user enabled it
    if bpy.context.preferences.addons["cycles"].preferences.compute_device_type == "CUDA":
        scene.cycles.device = "GPU"
    else:
        log.info('Using CPU for environment render (might be slow). Enable CUDA if possible.')

    # One sample is enough for world background only
    scene.cycles.samples = 1

    # Setup scene
    cam = bpy.data.cameras.new("_arm_cam_envmap_render")
    cam_obj = bpy.data.objects.new("_arm_cam_envmap_render", cam)
    scene.collection.objects.link(cam_obj)
    scene.camera = cam_obj

    cam_obj.location = [0.0, 0.0, 0.0]
    cam.type = "PANO"
    cam.cycles.panorama_type = "EQUIRECTANGULAR"
    cam_obj.rotation_euler = [math.radians(90), 0, math.radians(-90)]

    try:
        yield
    finally:
        bpy.data.objects.remove(cam_obj)
        bpy.data.cameras.remove(cam)
        bpy.data.scenes.remove(scene)


def render_envmap(target_dir: str, world: bpy.types.World):
    """Renders an environment texture for the given world into the
    target_dir. Use in combination with setup_envmap_render()."""
    scene = bpy.data.scenes["_arm_envmap_render"]
    scene.world = world

    render_path = os.path.join(target_dir, f"env_{arm.utils.safesrc(world.name)}.jpg")
    scene.render.filepath = render_path

    bpy.ops.render.render(write_still=True, scene=scene.name)


def write_probes(image_filepath: str, disable_hdr: bool, cached_num_mips: int, arm_radiance=True) -> int:
    """Generate probes from environment map and returns the mipmap count"""
    envpath = arm.utils.get_fp_build() + '/compiled/Assets/envmaps'

    if not os.path.exists(envpath):
        os.makedirs(envpath)

    base_name = arm.utils.extract_filename(image_filepath).rsplit('.', 1)[0]

    # Assets to be generated
    output_file_irr = envpath + '/' + base_name + '_irradiance'
    output_file_rad = envpath + '/' + base_name + '_radiance'
    rad_format = 'jpg' if disable_hdr else 'hdr'

    # Radiance & irradiance exists, keep cache
    basep = envpath + '/' + base_name
    if os.path.exists(basep + '_irradiance.arm'):
        if not arm_radiance or os.path.exists(basep + '_radiance_0.' + rad_format):
            add_irr_assets(output_file_irr)
            if arm_radiance:
                add_rad_assets(output_file_rad, rad_format, cached_num_mips)
            return cached_num_mips

    # Get paths
    sdk_path = arm.utils.get_sdk_path()
    kha_path = arm.utils.get_kha_path()

    if arm.utils.get_os() == 'win':
        cmft_path = sdk_path + '/lib/armory_tools/cmft/cmft.exe'
        kraffiti_path = kha_path + '/Kinc/Tools/kraffiti/kraffiti.exe'
    elif arm.utils.get_os() == 'mac':
        cmft_path = '"' + sdk_path + '/lib/armory_tools/cmft/cmft-osx"'
        kraffiti_path = '"' + kha_path + '/Kinc/Tools/kraffiti/kraffiti-osx"'
    else:
        cmft_path = '"' + sdk_path + '/lib/armory_tools/cmft/cmft-linux64"'
        kraffiti_path = '"' + kha_path + '/Kinc/Tools/kraffiti/kraffiti-linux64"'

    output_gama_numerator = '2.2' if disable_hdr else '1.0'
    input_file = arm.utils.asset_path(image_filepath)

    # Scale map
    rpdat = arm.utils.get_rp()
    target_w = int(rpdat.arm_radiance_size)
    target_h = int(target_w / 2)
    scaled_file = output_file_rad + '.' + rad_format

    if arm.utils.get_os() == 'win':
        subprocess.check_output([
            kraffiti_path,
            'from=' + input_file,
            'to=' + scaled_file,
            'format=' + rad_format,
            'width=' + str(target_w),
            'height=' + str(target_h)])
    else:
        subprocess.check_output([
            kraffiti_path
            + ' from="' + input_file + '"'
            + ' to="' + scaled_file + '"'
            + ' format=' + rad_format
            + ' width=' + str(target_w)
            + ' height=' + str(target_h)], shell=True)

    # Irradiance spherical harmonics
    if arm.utils.get_os() == 'win':
        subprocess.call([
            cmft_path,
            '--input', scaled_file,
            '--filter', 'shcoeffs',
            '--outputNum', '1',
            '--output0', output_file_irr])
    else:
        subprocess.call([
            cmft_path
            + ' --input ' + '"' + scaled_file + '"'
            + ' --filter shcoeffs'
            + ' --outputNum 1'
            + ' --output0 ' + '"' + output_file_irr + '"'], shell=True)

    sh_to_json(output_file_irr)
    add_irr_assets(output_file_irr)

    # Mip-mapped radiance
    if not arm_radiance:
        return cached_num_mips

    # 4096 = 256 face
    # 2048 = 128 face
    # 1024 = 64 face
    face_size = target_w / 8
    if target_w == 2048:
        mip_count = 9
    elif target_w == 1024:
        mip_count = 8
    else:
        mip_count = 7

    wrd = bpy.data.worlds['Arm']
    use_opencl = 'true'

    # cmft doesn't work correctly when passing the number of logical
    # CPUs if there are more logical than physical CPUs on a machine
    cpu_count = arm.utils.cpu_count(physical_only=True)

    if arm.utils.get_os() == 'win':
        cmd = [
            cmft_path,
            '--input', scaled_file,
            '--filter', 'radiance',
            '--dstFaceSize', str(face_size),
            '--srcFaceSize', str(face_size),
            '--excludeBase', 'false',
            # '--mipCount', str(mip_count),
            '--glossScale', '8',
            '--glossBias', '3',
            '--lightingModel', 'blinnbrdf',
            '--edgeFixup', 'none',
            '--numCpuProcessingThreads', str(cpu_count),
            '--useOpenCL', use_opencl,
            '--clVendor', 'anyGpuVendor',
            '--deviceType', 'gpu',
            '--deviceIndex', '0',
            '--generateMipChain', 'true',
            '--inputGammaNumerator', output_gama_numerator,
            '--inputGammaDenominator', '1.0',
            '--outputGammaNumerator', '1.0',
            '--outputGammaDenominator', '1.0',
            '--outputNum', '1',
            '--output0', output_file_rad,
            '--output0params', 'hdr,rgbe,latlong'
        ]
        if wrd.arm_verbose_output:
            print(cmd)
        else:
            cmd.append('--silent')
        subprocess.call(cmd)
    else:
        cmd = cmft_path + \
            ' --input "' + scaled_file + '"' + \
            ' --filter radiance' + \
            ' --dstFaceSize ' + str(face_size) + \
            ' --srcFaceSize ' + str(face_size) + \
            ' --excludeBase false' + \
            ' --glossScale 8' + \
            ' --glossBias 3' + \
            ' --lightingModel blinnbrdf' + \
            ' --edgeFixup none' + \
            ' --numCpuProcessingThreads ' + str(cpu_count) + \
            ' --useOpenCL ' + use_opencl + \
            ' --clVendor anyGpuVendor' + \
            ' --deviceType gpu' + \
            ' --deviceIndex 0' + \
            ' --generateMipChain true' + \
            ' --inputGammaNumerator ' + output_gama_numerator + \
            ' --inputGammaDenominator 1.0' + \
            ' --outputGammaNumerator 1.0' + \
            ' --outputGammaDenominator 1.0' + \
            ' --outputNum 1' + \
            ' --output0 "' + output_file_rad + '"' + \
            ' --output0params hdr,rgbe,latlong'
        if wrd.arm_verbose_output:
            print(cmd)
        else:
            cmd += ' --silent'
        subprocess.call([cmd], shell=True)

    # Remove size extensions in file name
    mip_w = int(face_size * 4)
    mip_base = output_file_rad + '_'
    mip_num = 0
    while mip_w >= 4:
        mip_name = mip_base + str(mip_num)
        os.rename(
            mip_name + '_' + str(mip_w) + 'x' + str(int(mip_w / 2)) + '.hdr',
            mip_name + '.hdr')
        mip_w = int(mip_w / 2)
        mip_num += 1

    # Append mips
    generated_files = []
    for i in range(0, mip_count):
        generated_files.append(output_file_rad + '_' + str(i))

    # Convert to jpgs
    if disable_hdr is True:
        for f in generated_files:
            if arm.utils.get_os() == 'win':
                subprocess.call([
                    kraffiti_path,
                    'from=' + f + '.hdr',
                    'to=' + f + '.jpg',
                    'format=jpg'])
            else:
                subprocess.call([
                    kraffiti_path
                    + ' from="' + f + '.hdr"'
                    + ' to="' + f + '.jpg"'
                    + ' format=jpg'], shell=True)
            os.remove(f + '.hdr')

    # Scale from (4x2 to 1x1>
    for i in range(0, 2):
        last = generated_files[-1]
        out = output_file_rad + '_' + str(mip_count + i)
        if arm.utils.get_os() == 'win':
            subprocess.call([
                kraffiti_path,
                'from=' + last + '.' + rad_format,
                'to=' + out + '.' + rad_format,
                'scale=0.5',
                'format=' + rad_format], shell=True)
        else:
            subprocess.call([
                kraffiti_path
                + ' from=' + '"' + last + '.' + rad_format + '"'
                + ' to=' + '"' + out + '.' + rad_format + '"'
                + ' scale=0.5'
                + ' format=' + rad_format], shell=True)
        generated_files.append(out)

    mip_count += 2

    add_rad_assets(output_file_rad, rad_format, mip_count)

    return mip_count


def sh_to_json(sh_file):
    """Parse sh coefs produced by cmft into json array"""
    with open(sh_file + '.c') as f:
        sh_lines = f.read().splitlines()
    band0_line = sh_lines[5]
    band1_line = sh_lines[6]
    band2_line = sh_lines[7]

    irradiance_floats = []
    parse_band_floats(irradiance_floats, band0_line)
    parse_band_floats(irradiance_floats, band1_line)
    parse_band_floats(irradiance_floats, band2_line)
    for i in range(0, len(irradiance_floats)):
        irradiance_floats[i] /= 2

    sh_json = {'irradiance': irradiance_floats}
    ext = '.arm' if bpy.data.worlds['Arm'].arm_minimize else ''
    arm.utils.write_arm(sh_file + ext, sh_json)

    # Clean up .c
    os.remove(sh_file + '.c')


def parse_band_floats(irradiance_floats, band_line):
    string_floats = re.findall(r'[-+]?\d*\.\d+|\d+', band_line)
    string_floats = string_floats[1:]  # Remove 'Band 0/1/2' number
    for s in string_floats:
        irradiance_floats.append(float(s))


def write_sky_irradiance(base_name):
    # Hosek spherical harmonics
    irradiance_floats = [
        1.5519331988822218, 2.3352207154503266, 2.997277451988076,
        0.2673894962434794, 0.4305630474135794, 0.11331825259716752,
        -0.04453633521758638, -0.038753175134160295, -0.021302768541875794,
        0.00055858020486499, 0.000371654770334503, 0.000126606145406403,
        -0.000135708721978705, -0.000787399554583089, -0.001550090690860059,
        0.021947399048903773, 0.05453650591711572, 0.08783641266630278,
        0.17053593578630663, 0.14734127083304463, 0.07775404698816404,
        -2.6924363189795e-05, -7.9350169701934e-05, -7.559914435231e-05,
        0.27035455385870993, 0.23122918445556914, 0.12158817295211832]
    for i in range(0, len(irradiance_floats)):
        irradiance_floats[i] /= 2

    envpath = os.path.join(arm.utils.get_fp_build(), 'compiled', 'Assets', 'envmaps')
    if not os.path.exists(envpath):
        os.makedirs(envpath)

    output_file = os.path.join(envpath, base_name + '_irradiance')

    sh_json = {'irradiance': irradiance_floats}
    arm.utils.write_arm(output_file + '.arm', sh_json)

    assets.add(output_file + '.arm')


def write_color_irradiance(base_name, col):
    """Constant color irradiance"""
    # Adjust to Cycles
    irradiance_floats = [col[0] * 1.13, col[1] * 1.13, col[2] * 1.13]
    for i in range(0, 24):
        irradiance_floats.append(0.0)

    envpath = os.path.join(arm.utils.get_fp_build(), 'compiled', 'Assets', 'envmaps')
    if not os.path.exists(envpath):
        os.makedirs(envpath)

    output_file = os.path.join(envpath, base_name + '_irradiance')

    sh_json = {'irradiance': irradiance_floats}
    arm.utils.write_arm(output_file + '.arm', sh_json)

    assets.add(output_file + '.arm')