#! /usr/bin/python
import re
import time

from utilities.render_worker import *

SUPPORTED_FORMATS = ['TGA', 'RAWTGA', 'JPEG', 'IRIS', 'IRIZ', 'AVIRAW', 'AVIJPEG', 'PNG', 'BMP', 'HDR', 'TIFF',
                     'OPEN_EXR', 'OPEN_EXR_MULTILAYER', 'MPEG', 'CINEON', 'DPX', 'DDS', 'JP2']


class BlenderRenderWorker(BaseRenderWorker):

    def version(self):
        version = None
        try:
            ver_out = subprocess.check_output([self.renderer_path(), '-v']).decode('utf-8')
            version = ver_out.splitlines()[0].replace('Blender', '').strip()
        except Exception as e:
            logger.error("Failed to get Blender version: {}".format(e))
        return version

    renderer = 'Blender'
    render_engine = 'blender'
    supported_extensions = ['.blend']
    install_paths = ['/Applications/Blender.app/Contents/MacOS/Blender']

    def __init__(self, input_path, output_path, args=None, render_all_frames=False, engine='BLENDER_EEVEE'):
        super(BlenderRenderWorker, self).__init__(input_path=input_path, output_path=output_path, args=args)

        self.engine = engine  # or 'CYCLES'
        self.format = 'JPEG'
        self.frame = 0

        self.render_all_frames = render_all_frames

        # Stats
        self.current_frame = -1
        self.memory_use = None
        self.time_elapsed = None
        self.time_remaining = None
        self.frame_percent_complete = 0.0

    def generate_preview(self, blend_file):
        pass

    def _generate_subprocess(self):

        if self.format not in SUPPORTED_FORMATS:
            raise ValueError("Unsupported format for Blender: {}".format(self.format))

        if self.render_all_frames:
            cmd = [self.renderer_path(), '-b', self.input, '-E', self.engine, '-o', self.output,
                   '-F', self.format, '-a']
        else:
            cmd = [self.renderer_path(), '-b', self.input, '-E', self.engine, '-o', self.output,
                   '-F', self.format, '-f', str(self.frame)]
        return cmd

    def _parse_stdout(self, line):
        import re
        pattern = re.compile(
            r'Fra:(?P<frame>\d*).*Mem:(?P<memory>\S+).*Time:(?P<time>\S+)(?:.*Remaining:)?(?P<remaining>\S*)')
        found = pattern.search(line)
        if found:
            stats = found.groupdict()
            self.memory_use = stats['memory']
            self.time_elapsed = stats['time']
            self.time_remaining = stats['remaining'] or 'Unknown'

            sample_string = line.split('|')[-1].strip()
            if "sample" in sample_string.lower():
                samples = re.sub(r'[^\d/]', '', sample_string)
                self.frame_percent_complete = int(samples.split('/')[0]) / int(samples.split('/')[-1])


            # Calculate rough percent based on cycles
            # EEVEE
            # 10-Apr-22 22:42:06 - RENDERER: Fra:0 Mem:857.99M (Peak 928.55M) | Time:00:03.96 | Rendering 1 / 65 samples
            # 10-Apr-22 22:42:10 - RENDERER: Fra:0 Mem:827.09M (Peak 928.55M) | Time:00:07.92 | Rendering 26 / 64 samples
            # 10-Apr-22 22:42:10 - RENDERER: Fra:0 Mem:827.09M (Peak 928.55M) | Time:00:08.17 | Rendering 51 / 64 samples
            # 10-Apr-22 22:42:10 - RENDERER: Fra:0 Mem:827.09M (Peak 928.55M) | Time:00:08.31 | Rendering 64 / 64 samples

            # CYCLES
            # 10-Apr-22 22:43:22 - RENDERER: Fra:0 Mem:836.30M (Peak 1726.13M) | Time:00:01.56 | Remaining:00:30.65 | Mem:588.68M, Peak:588.68M | Scene, View Layer | Sample 1/150
            # 10-Apr-22 22:43:43 - RENDERER: Fra:0 Mem:836.30M (Peak 1726.13M) | Time:00:22.01 | Remaining:00:03.36 | Mem:588.68M, Peak:588.68M | Scene, View Layer | Sample 129/150

            if int(stats['frame']) > self.current_frame:
                self.current_frame = int(stats['frame'])
                logger.info(
                    'Frame:{0} | Mem:{1} | Time:{2} | Remaining:{3}'.format(self.current_frame, self.memory_use,
                                                                            self.time_elapsed, self.time_remaining))
        elif 'error' in line.lower():
            logger.error(line)
            self.errors.append(line)
        elif 'Saved' in line or 'Saving' in line or 'quit' in line:
            x = re.match(r'Time: (.*) \(Saving', line)
            if x:
                time_completed = x.groups()[0]
                logger.info('Render completed in {}'.format(time_completed))
            else:
                logger.info(line)
        else:
            pass
            # if len(line.strip()):
            #     logger.debug(line.strip())

    def percent_complete(self):
        if self.total_frames <= 1:
            return self.frame_percent_complete
        else:
            return (self.current_frame / self.total_frames) + \
                   (self.frame_percent_complete * (self.current_frame / self.total_frames))


def pack_blender_files(path):
    # Credit to L0Lock for pack script - https://blender.stackexchange.com/a/243935
    pack_script = "import bpy\nbpy.ops.file.pack_all()\nmyPath = bpy.data.filepath\nmyPath = str(myPath)\n" \
                  "bpy.ops.wm.save_as_mainfile(filepath=myPath[:-6]+'_packed'+myPath[-6:])"

    if os.path.exists(path):
        try:
            results = subprocess.check_output(['blender', '-b', path, '--python-expr', pack_script])
            result_text = results.decode()
            dir_name = os.path.dirname(path)

            p = re.compile('Info: Saved "(.*)"')
            match = p.search(result_text)
            new_path = os.path.join(dir_name, match.group(1))
            return new_path
        except Exception as e:
            logger.error(f'Error packing .blend file: {e}')
    return None


if __name__ == '__main__':

    # x = pack_blender_files('/Users/brett/Blender Files/temple_animatic.blend')
    # print(x)

    logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.DEBUG)
    r = BlenderRenderWorker('/Users/brett/Blender Files/temple_animatic.blend', '/Users/brett/testing1234')
    # r.engine = 'CYCLES'
    r.start()
    while r.is_running():
        time.sleep(1)