import sys

import os

from collections import deque

from threading import Thread

from config.Configuration import env

from resources.LeapSDK.v53_python39 import Leap

from LeapData import LeapData

from resources.pymo.pymo.writers import BVHWriter as Pymo_BVHWriter

# from resources.b3d.bvh_reader import BVH as B3D_BVHReader

# from resources.b3d.c3d_convertor import Convertor as B3D_C3DWriter

from AnyWriter import AnyWriter

from BVHAnimation import bvh_animation

# from resources.virb import Virb

_LEAP_QUEUE = deque()

class LeapRecord(Leap.Listener):

    def __init__(self):

        super(LeapRecord, self).__init__()

        # Initialize Leap2DataFrame parser

        self.fps = int(env.config.frames_per_second)

        basis_setting = True if env.args('anybody_basis') else False

        self.leap2bvh = LeapData(channel_setting=env.config.channels,

                                 frame_rate=1 / self.fps,

                                 anybody_basis=basis_setting)

        self.bvh_write = env.config.bvh

        if self.bvh_write:

            self.bvh_filename = os.path.normpath(

                os.path.join(os.path.split(env.config.bvh_path)[0],

                             os.path.split(env.config.bvh_path)[1].replace(".bvh", "") + '.bvh'))

        # self.c3d_write = env.config.c3d

        # if self.c3d_write:

        #     self.c3d_filename = env.config.c3d_path + '\\' + env.config.c3d_filename + '.c3d'

        self.anybody_write = env.config.anybody

        if self.anybody_write:

            self.anybody_template_path = env.config.anybody_template_path + '\\'

            self.anybody_output_path = env.config.anybody_output_path + '\\'

        self.processing = True

        self.t = None

        self.last_time = 0

        # self.garmin = Virb(host=('192.168.137.34', 80))

    def on_init(self, controller):

        self.t = Thread(target=self.process_frame, args=(self,))

        # self.garmin.start_recording()

        self.t.start()

        print("Initialized")

    def on_connect(self, controller):

        print("Connected")

        print("=====================")

    def on_disconnect(self, controller):

        # Note: not dispatched when running in a debugger.

        print("Disconnected")

    def on_exit(self, controller):

        print("=====================")

        print("Exited")

        # self.garmin.stop_recording()

    def on_frame(self, controller):

        # Get the most recent frame

        frame = controller.frame()

        _LEAP_QUEUE.append(frame)

        # self.leap2bvh.add_frame(controller.frame())

    @staticmethod

    def process_frame(listener):

        while listener.processing:

            try:

                while True:

                    frame = _LEAP_QUEUE.popleft()

                    if frame.timestamp - listener.last_time > int(1000000 / listener.fps):

                        added_frame = listener.leap2bvh.add_frame(frame)

                        if added_frame:

                            # print(added_frame.timestamp - listener.last_time)

                            listener.last_time = added_frame.timestamp

            except IndexError:

                pass

    def exit(self):

        self.processing = False

        self.t.join()

        self.exit_actions()

    def exit_actions(self):

        bvh_data = self.leap2bvh.parse()

        if self.bvh_write:

            bvh_writer = Pymo_BVHWriter()

            bvh_file = open(self.bvh_filename, 'w')

            bvh_writer.write(bvh_data, bvh_file)

            bvh_file.close()

            print('"{}" written'.format(bvh_file.name))

        # if self.c3d_write:

        #     # workaround, need bvh

        #     bvh_writer = Pymo_BVHWriter()

        #     bvh_file = open(self.c3d_filename.strip('.c3d') + '-tmp.bvh', 'w')

        #     bvh_writer.write(bvh_data, bvh_file)

        #     bvh_file.close()

        #     print('"{}" written'.format(bvh_file.name))

        #

        #     bvh_reader = B3D_BVHReader()

        #     if not bvh_reader.load_from_file(bvh_file.name):

        #         raise Exception('error: can not read "{}"'.format(bvh_file.name))

        #

        #     c3d_writer = B3D_C3DWriter()

        #     c3d_writer.convert(bvh_reader, self.c3d_filename)

        #     print('"{}" written from "{}"'.format(self.c3d_filename, bvh_file.name))

        #

        #     os.remove(bvh_file.name)

        #     print('"{}" deleted'.format(bvh_file.name))

        if self.anybody_write:

            AnyWriter(template_directory=self.anybody_template_path,

                      output_directory=self.anybody_output_path

                      ).write(bvh_data)

            print('Anybody files written to "{}"'.format(self.anybody_output_path))

        bvh_animation.bvh_data = bvh_data

def start_recording():

    # Create a listener and controller

    listener = LeapRecord()

    controller = Leap.Controller()

    # Have the listener receive events from the controller

    controller.add_listener(listener)

    # Keep this process running until Enter is pressed

    print("Listener added")

    try:

        sys.stdin.readline()

    except KeyboardInterrupt:

        pass

    finally:

        # Remove the listener when done

        controller.remove_listener(listener)

        print("Listener removed")

        listener.exit()