#!/usr/bin/env python3
# SPDX-License-Identifier: MPL-2.0
"""Bounded libhybris preview worker. Frames stay in memory; no microphone access.

The parent owns stdin. EOF or five seconds without a request closes the sensor.
A pbuffer and external texture are required even for the software NV21 callback.
"""
import argparse
import struct
import ctypes as C
import json
import os
import select
import sys
import time


def function(lib, name, args, result=None):
    value = getattr(lib, name)
    value.argtypes, value.restype = args, result
    return value


class Listener(C.Structure):
    _fields_ = [(name, C.c_void_p) for name in
                ('error', 'shutter', 'focus', 'zoom', 'raw', 'jpeg', 'texture', 'context', 'preview')]


class Camera:
    width, height = 640, 480

    def __init__(self, index):
        self.camera = None
        self.display = self.surface = self.context = None
        self.frame = None
        self.jpeg = None
        self.focus_done = False
        self.count = self.errors = 0
        self.texture_pending = False
        os.environ['HYBRIS_EGLPLATFORM'] = 'null'
        os.environ['__EGL_VENDOR_LIBRARY_FILENAMES'] = '/usr/share/glvnd/egl_vendor.d/10_libhybris.json'
        self.egl = C.CDLL('libEGL.so.1')
        self.gl = C.CDLL('libGLESv2.so.2')
        self.lib = C.CDLL('libcamera.so.1')
        P, I, U = C.c_void_p, C.c_int, C.c_uint
        self.display = function(self.egl, 'eglGetDisplay', [P], P)(None)
        if not function(self.egl, 'eglInitialize', [P, P, P], U)(self.display, None, None):
            raise RuntimeError('CAMERA_EGL_INIT_FAILED')
        attrs = (I * 13)(0x3033, 1, 0x3040, 4, 0x3024, 8, 0x3023, 8, 0x3022, 8, 0x3021, 8, 0x3038)
        config, count = P(), I()
        function(self.egl, 'eglChooseConfig', [P, P, P, I, P], U)(self.display, attrs, C.byref(config), 1, C.byref(count))
        if not count.value:
            raise RuntimeError('CAMERA_EGL_CONFIG_FAILED')
        function(self.egl, 'eglBindAPI', [U], U)(0x30A0)
        self.context = function(self.egl, 'eglCreateContext', [P, P, P, P], P)(self.display, config, None, (I * 3)(0x3098, 2, 0x3038))
        self.surface = function(self.egl, 'eglCreatePbufferSurface', [P, P, P], P)(self.display, config, (I * 5)(0x3057, 16, 0x3056, 16, 0x3038))
        if not function(self.egl, 'eglMakeCurrent', [P, P, P, P], U)(self.display, self.surface, self.surface, self.context):
            raise RuntimeError('CAMERA_EGL_CONTEXT_FAILED')
        texture = U()
        function(self.gl, 'glGenTextures', [I, P])(1, C.byref(texture))

        @C.CFUNCTYPE(None, P, U, P)
        def preview(data, size, _context):
            if size == self.width * self.height * 3 // 2:
                self.frame = C.string_at(data, size)
                self.count += 1

        @C.CFUNCTYPE(None, P)
        def error(_context):
            self.errors += 1

        @C.CFUNCTYPE(None, P)
        def available(_context):
            self.texture_pending = True

        @C.CFUNCTYPE(None, P)
        def focused(_context):
            self.focus_done = True

        @C.CFUNCTYPE(None, P, U, P)
        def jpeg(data, size, _context):
            if 0 < size <= 32 * 1024 * 1024:
                self.jpeg = C.string_at(data, size)

        self.callbacks = (preview, error, available, focused, jpeg)
        self.listener = Listener()
        for name, callback in [('preview', preview), ('error', error), ('texture', available), ('focus', focused), ('jpeg', jpeg)]:
            setattr(self.listener, name, C.cast(callback, P).value)
        self.camera = function(self.lib, 'android_camera_connect_by_id', [I, P], P)(index, C.byref(self.listener))
        if not self.camera:
            raise RuntimeError('CAMERA_CONNECT_FAILED')
        facing, orientation = I(), I()
        function(self.lib, 'android_camera_get_device_info', [I, P, P], I)(index, C.byref(facing), C.byref(orientation))
        self.orientation = orientation.value
        function(self.lib, 'android_camera_set_preview_size', [P, I, I])(self.camera, self.width, self.height)
        function(self.lib, 'android_camera_set_preview_format', [P, I])(self.camera, 1)  # YUV420SP / NV21
        function(self.lib, 'android_camera_set_preview_texture', [P, I])(self.camera, texture.value)
        function(self.lib, 'android_camera_set_preview_callback_mode', [P, I], I)(self.camera, 1)
        function(self.lib, 'android_camera_start_preview', [P])(self.camera)
        self.parameters = self.read_parameters()
        self.picture_sizes = [tuple(map(int, size.split('x'))) for size in self.parameters.get('picture-size-values', '').split(',') if 'x' in size]
        self.picture_size = max(self.picture_sizes, key=lambda size:size[0]*size[1])
        self.zoom_ratios = [int(n)/100 for n in self.parameters.get('zoom-ratios', '100').split(',')]

    def read_parameters(self):
        # libhybris exposes the flattened parameters through a stdout dump.
        # Capture it in RAM so it cannot corrupt the worker's binary protocol.
        libc = C.CDLL(None)
        fd = os.memfd_create('camera-parameters')
        saved = os.dup(1)
        try:
            libc.fflush(None)
            os.dup2(fd, 1)
            function(self.lib, 'android_camera_dump_parameters', [C.c_void_p])(self.camera)
            libc.fflush(None)
        finally:
            os.dup2(saved, 1)
            os.close(saved)
        try:
            os.lseek(fd, 0, 0)
            raw = os.read(fd, 65536).decode()
            return dict(item.split('=', 1) for item in raw.strip().split(';') if '=' in item)
        finally:
            os.close(fd)

    def metadata(self):
        return {'ready': True, 'width': self.width, 'height': self.height,
                'orientation': self.orientation, 'format': 'nv21',
                'pictureSizes': [{'width':w,'height':h} for w,h in self.picture_sizes],
                'focusModes': self.parameters.get('focus-mode-values', 'fixed').split(','),
                'maxFocusAreas': min(1,int(self.parameters.get('max-num-focus-areas', 0))),
                'zoomRatios': self.zoom_ratios}

    def control(self, command):
        P, I = C.c_void_p, C.c_int
        action = command.get('action')
        if action == 'zoom':
            ratio = command.get('zoom')
            if not isinstance(ratio, (int,float)) or not self.zoom_ratios[0] <= ratio <= self.zoom_ratios[-1]:
                raise ValueError('CAMERA_INVALID_ZOOM')
            index = min(range(len(self.zoom_ratios)), key=lambda i:abs(self.zoom_ratios[i]-ratio))
            function(self.lib,'android_camera_set_zoom',[P,I])(self.camera,index)
            actual = int(self.read_parameters().get('zoom',index))
            if not 0 <= actual < len(self.zoom_ratios): raise RuntimeError('CAMERA_INVALID_ZOOM_REPLY')
            return {'zoom':self.zoom_ratios[actual]}
        if action == 'focus':
            if 'auto' not in self.metadata()['focusModes']:
                raise ValueError('CAMERA_FOCUS_UNAVAILABLE')
            function(self.lib,'android_camera_stop_autofocus',[P])(self.camera)
            function(self.lib,'android_camera_set_auto_focus_mode',[P,I])(self.camera,2)
            area = command.get('area')
            if area is not None:
                values = [area.get(k) for k in ('top','left','bottom','right')]
                if any(not isinstance(n,int) or not -1000 <= n <= 1000 for n in values) or values[0]>=values[2] or values[1]>=values[3]:
                    raise ValueError('CAMERA_INVALID_FOCUS_AREA')
                if not self.metadata()['maxFocusAreas']:
                    raise ValueError('CAMERA_FOCUS_AREA_UNAVAILABLE')
                region = (I*5)(*values,1000)
                function(self.lib,'android_camera_set_focus_region',[P,P])(self.camera,region)
            else:
                function(self.lib,'android_camera_reset_focus_region',[P])(self.camera)
            self.focus_done = False
            function(self.lib,'android_camera_start_autofocus',[P])(self.camera)
            deadline = time.monotonic()+4
            while not self.focus_done and time.monotonic()<deadline:
                self.tick(); time.sleep(.01)
            if not self.focus_done:
                raise RuntimeError('CAMERA_FOCUS_TIMEOUT')
            return {'completed':True}
        if action == 'picture':
            size = command.get('size') or dict(zip(('width','height'),self.picture_size))
            pair = (size.get('width'),size.get('height'))
            if pair not in self.picture_sizes:
                raise ValueError('CAMERA_INVALID_PICTURE_SIZE')
            function(self.lib,'android_camera_set_picture_size',[P,I,I])(self.camera,*pair)
            function(self.lib,'android_camera_set_jpeg_quality',[P,I])(self.camera,95)
            function(self.lib,'android_camera_set_rotation',[P,I])(self.camera,self.orientation)
            self.jpeg = None
            try:
                function(self.lib,'android_camera_take_snapshot',[P])(self.camera)
                deadline = time.monotonic()+12
                while self.jpeg is None and time.monotonic()<deadline:
                    self.tick(); time.sleep(.01)
                if self.jpeg is None:
                    raise RuntimeError('CAMERA_CAPTURE_TIMEOUT')
                return self.jpeg
            finally:
                function(self.lib,'android_camera_start_preview',[P])(self.camera)
        raise ValueError('CAMERA_INVALID_COMMAND')

    def tick(self):
        if self.texture_pending:
            self.texture_pending = False
            function(self.lib, 'android_camera_update_preview_texture', [C.c_void_p])(self.camera)

    def close(self):
        P = C.c_void_p
        if self.camera:
            function(self.lib, 'android_camera_stop_preview', [P])(self.camera)
            function(self.lib, 'android_camera_disconnect', [P])(self.camera)
            self.camera = None
        if self.display:
            function(self.egl, 'eglMakeCurrent', [P, P, P, P], C.c_uint)(self.display, None, None, None)
            if self.surface:
                function(self.egl, 'eglDestroySurface', [P, P], C.c_uint)(self.display, self.surface)
            if self.context:
                function(self.egl, 'eglDestroyContext', [P, P], C.c_uint)(self.display, self.context)
            function(self.egl, 'eglTerminate', [P], C.c_uint)(self.display)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--camera', type=int, choices=(0, 1), default=0)
    parser.add_argument('--probe', action='store_true', help='Count frames for five seconds, retain no images')
    args = parser.parse_args()
    output = os.fdopen(os.dup(1), 'wb', buffering=0)
    os.dup2(2, 1)  # HAL callbacks can print; keep stdout protocol uncontaminated.
    camera = None
    try:
        camera = Camera(args.camera)
        started = last_request = time.monotonic()
        if not args.probe:
            metadata = json.dumps(camera.metadata()).encode()
            output.write(struct.pack('<I', len(metadata)) + metadata)
            output.flush()
        while time.monotonic() - last_request < 5:
            camera.tick()
            if args.probe:
                time.sleep(.01)
                continue
            if not select.select([sys.stdin], [], [], .01)[0]:
                continue
            command = sys.stdin.readline(4096)
            if not command or len(command)>=4096:
                break
            last_request = time.monotonic()
            if command == 'frame\n':
                data = camera.frame or b''
                output.write(struct.pack('<II', camera.count & 0xffffffff, len(data)))
                output.write(data)
            else:
                try:
                    result = camera.control(json.loads(command))
                    if isinstance(result,bytes):
                        data = json.dumps({'ok':True,'jpegLength':len(result)}).encode()
                    else:
                        data = json.dumps({'ok':True,'result':result}).encode()
                except (ValueError,RuntimeError,TypeError,AttributeError) as error:
                    result = None
                    data = json.dumps({'ok':False,'error':str(error)}).encode()
                output.write(struct.pack('<I',len(data))+data)
                if isinstance(result,bytes):
                    output.write(result)
            output.flush()
            last_request = time.monotonic()
        if args.probe:
            output.write((json.dumps({'camera': args.camera, 'frames': camera.count, 'errors': camera.errors,
                              'width': camera.width, 'height': camera.height, 'orientation': camera.orientation,
                              'seconds': round(time.monotonic() - started, 2), 'imagesRetained': False})+'\n').encode())
            if not camera.count or camera.errors:
                return 1
        return 0
    finally:
        if camera:
            camera.close()


if __name__ == '__main__':
    sys.exit(main())