"""Versioned metre interpretation without rewriting raw sources or human history."""
from __future__ import annotations

import copy
import fcntl
import hashlib
import io
import json
import math
from pathlib import Path
import secrets

import numpy as np

from .cluster_targets import digest
from .pose_review_geometry import canonical,pose_value,sensor_value


class MetrePolicy:
    def __init__(self,config,sha256=None):
        self.config=copy.deepcopy(config)
        self.sha256=sha256 or hashlib.sha256(canonical(config)).hexdigest()
        self.id=config['policy_id']+':'+self.sha256[:16]
        for scale in [config['unknown_default_scale_to_m'],*config['unknown_size_overrides'].values()]:
            if not math.isfinite(scale) or scale<=0:raise ValueError('Invalid metre conversion policy')

    @classmethod
    def load(cls,path,dataset):
        path=Path(path)
        if not path.exists():return None
        value=json.loads(path.read_text())
        # Isolated synthetic datasets and previous frozen experiments do not
        # silently inherit a production-only unit interpretation.
        if value['formal_manifest_sha256']!=digest(Path(dataset)/'manifest.json'):return None
        return cls(value,digest(path))

    def native_scale(self,source):
        registered=source['sensor_policy'].get('scale_to_mm')
        if registered is not None:return registered/1000.
        size='x'.join(map(str,source['size']))
        return self.config['unknown_size_overrides'].get(size,self.config['unknown_default_scale_to_m'])

    def sensor(self,sensor,source):
        value=sensor_value(sensor,source)
        if value['scale_to_m'] is None:
            scale=self.native_scale(source)
            value.update(scale_to_m=scale,evidence=(
                '米制单位策略v1：用户明确确认240×96原单位毫米，乘0.001转米；其他原未知单位按用户确认以米解释。'
                '仅单位解释，不等于工厂标定、轴向或位姿已确认。'))
            value=sensor_value(value,source)
        return value

    def info(self,source=None):
        value=dict(id=self.id,sha256=self.sha256,position_unit='m',translation_step_m=.001,
                   evidence_kind='explicit_user_confirmation_not_factory_calibration')
        if source is not None:value['native_scale_to_m']=self.native_scale(source)
        return value

    def geometry(self,engine,meta,source,sensor):
        """Scale an immutable geometry revision, preserving measured face IDs.

        This is not a new automatic segmentation. Old and new tokens remain
        distinct, and every selected source-point index survives unchanged.
        """
        if meta['sensor']==sensor:return meta
        for field in ('forward_axis','up_axis','forward_sign','up_sign','axes_confirmed'):
            if meta['sensor'][field]!=sensor[field]:raise ValueError('单位转换不能代替坐标轴重提取')
        old_scale=meta['sensor']['scale_to_m']
        ratio=sensor['scale_to_m']/(old_scale if old_scale is not None else 1.)
        binding=dict(adapter='metre_geometry_preserve_faces_v1',policy=self.id,parent=meta['token'],sensor=sensor,
                     parent_points_sha256=meta['full_resolution_artifact_sha256'])
        token=hashlib.sha256(canonical(binding)).hexdigest();folder=engine.cache
        with engine.semaphore,(folder/(token+'.unit.lock')).open('a') as lock:
            fcntl.flock(lock,fcntl.LOCK_EX)
            if all((folder/(token+ext)).exists() for ext in ('.json','.npz','.bin')):
                return engine.load(token,meta['target_key'])
            old=folder/(meta['token']+'.npz')
            if digest(old)!=meta['full_resolution_artifact_sha256']:raise ValueError('旧点云证据哈希变化，拒绝单位转换')
            with np.load(old,allow_pickle=False) as z:arrays={k:z[k].copy() for k in z.files}
            arrays['xyz']*=ratio
            stream=io.BytesIO();np.savez_compressed(stream,**arrays)
            preview=np.frombuffer((folder/(meta['token']+'.bin')).read_bytes(),dtype='<f4').copy().reshape(-1,5)
            preview[:,:3]*=ratio
            converted=copy.deepcopy(meta);converted.update(token=token,sensor=sensor,
                unit_conversion=dict(**binding,length_multiplier=ratio,face_ids_and_source_indices_preserved=True))
            for candidate in [*converted['candidates'],converted['manual']]:
                candidate['center']=(np.asarray(candidate['center'])*ratio).tolist()
                candidate['half_width']*=ratio
                if 'residual_median' in candidate:candidate['residual_median']*=ratio
            for ext,raw in (('.npz',stream.getvalue()),('.bin',preview.astype('<f4').tobytes())):
                path=folder/(token+ext);tmp=folder/(token+'.'+secrets.token_hex(6)+'.tmp')
                tmp.write_bytes(raw);tmp.replace(path)
            converted['full_resolution_artifact_sha256']=digest(folder/(token+'.npz'))
            path=folder/(token+'.json');tmp=folder/(token+'.'+secrets.token_hex(6)+'.tmp')
            tmp.write_bytes(canonical(converted));tmp.replace(path)
            return converted

    def review(self,value,source,engine):
        if value is None:return None
        old_sensor=value['sensor'];sensor=self.sensor(old_sensor,source)
        if sensor==old_sensor:return copy.deepcopy(value)
        result=copy.deepcopy(value)
        old_scale=old_sensor['scale_to_m'];ratio=sensor['scale_to_m']/(old_scale if old_scale is not None else 1.)
        result['sensor']=sensor
        ruler=result.get('ruler')
        if ruler:
            ruler['origin']=(np.asarray(ruler['origin'])*ratio).tolist()
            for field in ('w','d','half_width'):ruler[field]*=ratio
        for exclusion in result.get('exclusions',[]):
            exclusion['origin']=(np.asarray(exclusion['origin'])*ratio).tolist()
            exclusion['bounds']=(np.asarray(exclusion['bounds'])*ratio).tolist()
        if result.get('view'):
            for field in ('centerW','centerD','centerH','span'):
                if field in result['view']:result['view'][field]*=ratio
        if result.get('geometry_token'):
            meta=engine.load(result['geometry_token'],result['target_key'])
            result['geometry_token']=self.geometry(engine,meta,source,sensor)['token']
        if result.get('pose') is not None and ruler:result['pose']=pose_value(ruler,sensor)
        # Unit authorization is not a new independent confirmation of a pose.
        result.update(pose_status='pending',human_pose_confirmed=False,metric_pose_confirmed=False,
            automatic_training_eligible=False,robot_command_eligible=False,
            unit_interpretation=dict(policy_id=self.id,source_revision=value.get('revision'),
                source_state=value.get('state'),
                original_record_sha256=hashlib.sha256(canonical(value)).hexdigest(),
                old_scale_to_m=old_scale,new_scale_to_m=sensor['scale_to_m'],length_multiplier=ratio,
                historical_record_unchanged=True))
        if result['state']=='complete':result['state']='draft'
        return result
