#!/usr/bin/env python3
"""Grouped native tables with explicit per-column bars and status marks."""
from __future__ import annotations

from copy import deepcopy
import json
import math
from pathlib import Path
import re
import sys
import unicodedata
import xml.etree.ElementTree as ET

import template_ref as ref
from component_typography import resolve_role

SVG = 'http://www.w3.org/2000/svg'


def _fields(value, allowed, required, name):
    ref.require(isinstance(value, dict), f'{name}: object required')
    ref.require(set(value) <= allowed, f'{name}: unknown fields {sorted(set(value)-allowed)}')
    ref.require(required <= set(value), f'{name}: missing fields {sorted(required-set(value))}')


def _number(value, name):
    ref.require(type(value) in (int, float) and math.isfinite(value), f'{name}: finite number required')
    return value


def _text(value, name, empty=False):
    ref.require(isinstance(value, str) and (empty or bool(value.strip())), f'{name}: string required')
    ref.require(not any(unicodedata.category(c).startswith('C') for c in value), f'{name}: control/format characters unsupported')
    return value


def _indices(value, count, name):
    ref.require(isinstance(value, list) and all(type(i) is int and 0 <= i < count for i in value), f'{name}: invalid column index')
    ref.require(len(set(value)) == len(value), f'{name}: duplicate column index')
    return value


def _fit(value, width, size, name):
    units = sum(1 if unicodedata.east_asian_width(c) in ('W', 'F') else .6 for c in value)
    ref.require(units*size <= width, f'{name}: text exceeds capacity; shorten text or enlarge bounds')


def _node(parent, tag, **attributes):
    return ET.SubElement(parent, '{'+SVG+'}'+tag, {key.replace('_', '-'):str(value) for key,value in attributes.items()})


def _label(parent, value, x, y, font, size, color, align, weight='normal'):
    result = _node(parent, 'text', x=x, y=y, font_family=font, font_size=size,
                   font_weight=weight, fill=color, text_anchor='end' if align == 'r' else 'middle' if align == 'ctr' else 'start')
    result.text = value


def _formatted(value, column):
    kind = column.get('format', 'text')
    if kind == 'integer':
        ref.require(type(value) in (int,float) and value == int(value), 'integer format requires integral numeric values')
        return f'{int(value):,}'
    if kind == 'one-decimal':
        ref.require(type(value) in (int,float), 'one-decimal format requires numeric values')
        return f'{value:,.1f}'
    return str(value)


def render_grouped_table(raw: dict, style: dict, theme: dict, bounds: tuple,
                         component_id: str) -> ET.Element:
    """Return an outer g containing a native-table marker and separate shapes.

    Original values are retained; number formats affect display text only. Bars
    express independent zero-based column magnitudes, never a ranking or score.
    """
    allowed = {'schema_version','kind','variant','data_kind','source','columns','rows','column_widths',
               'numeric_columns','column_groups','focus_row','row_header_columns','bars','status',
               'focus_meaning','bar_meaning'}
    _fields(raw, allowed, {'schema_version','kind','variant','columns','rows','column_widths','column_groups'}, 'grouped table')
    ref.require(type(raw['schema_version']) is int and raw['schema_version'] == 1 and raw['kind'] == 'table' and raw['variant'] == 'grouped', 'requires table/grouped schema_version 1')
    data = deepcopy(raw)
    if 'data_kind' in data:
        ref.require(data['data_kind'] in ('synthetic-demo','observed','derived'), 'invalid data_kind')
    for key in ('source','focus_meaning','bar_meaning'):
        if key in data: _text(data[key], key, empty=True)
    ref.identifier(component_id, 'component ID')
    ref.require(isinstance(bounds, (tuple,list)) and len(bounds) == 4, 'bounds requires x/y/width/height')
    x,y,width,height = [_number(v, 'bounds') for v in bounds]
    canvas = style['canvas']
    ref.require(x >= 0 and y >= 0 and width > 0 and height > 0 and x+width <= canvas['width'] and y+height <= canvas['height'], 'bounds outside canvas')
    columns, rows = data['columns'], data['rows']
    ref.require(isinstance(columns,list) and bool(columns), 'columns must be nonempty list')
    ids = []
    for col in columns:
        _fields(col, {'id','label','unit','format'}, {'id','label'}, 'column')
        ids.append(ref.identifier(col['id'], 'column ID'))
        _text(col['label'], 'column label')
        if 'unit' in col: _text(col['unit'], 'column unit', empty=True)
        ref.require(col.get('format','text') in ('text','integer','one-decimal'), 'unknown column format')
    count = len(columns)
    ref.require(len(set(ids)) == count, 'duplicate column ID')
    ref.require(isinstance(rows,list) and bool(rows), 'rows must be nonempty list')
    for row in rows:
        ref.require(isinstance(row,list) and len(row) == count, 'table row length mismatch')
        for value in row:
            if type(value) in (int,float): _number(value, 'cell')
            else: _text(value, 'cell', empty=True)
    widths = data['column_widths']
    ref.require(isinstance(widths,list) and len(widths) == count, 'column_widths mismatch')
    ref.require(all(_number(v,'column width') > 0 for v in widths) and abs(sum(widths)-width) < .01, 'column widths must fill bounds width')
    numeric = _indices(data.get('numeric_columns',[]), count, 'numeric_columns')
    for row in rows:
        for col in numeric: _number(row[col], 'numeric cell')
    row_headers = _indices(data.get('row_header_columns',[]), count, 'row_header_columns')
    focus = data.get('focus_row')
    ref.require(focus is None or type(focus) is int and 0 <= focus < len(rows), 'focus_row invalid')
    groups = data['column_groups']
    ref.require(isinstance(groups,list) and bool(groups), 'column_groups must be nonempty list')
    cursor = 0
    for group in groups:
        _fields(group, {'label','start','span'}, {'label','start','span'}, 'column group')
        _text(group['label'],'column group label')
        ref.require(type(group['start']) is int and type(group['span']) is int and group['start'] == cursor and group['span'] > 0, 'column_groups must provide ordered contiguous coverage')
        cursor += group['span']
    ref.require(cursor == count, 'column_groups must cover all columns')
    bar_columns = []
    if 'bars' in data:
        _fields(data['bars'], {'columns'}, {'columns'}, 'bars')
        bar_columns = _indices(data['bars']['columns'], count, 'bars.columns')
        ref.require(set(bar_columns) <= set(numeric), 'bars require numeric_columns')
        for row in rows:
            for col in bar_columns: ref.require(row[col] >= 0, 'bars require nonnegative values')
    status = data.get('status')
    if status is not None:
        _fields(status, {'column','values'}, {'column','values'}, 'status')
        _indices([status['column']], count, 'status.column')
        ref.require(status['column'] not in numeric and status['column'] not in bar_columns, 'status column must be textual')
        ref.require(isinstance(status['values'],dict) and bool(status['values']), 'status.values must be nonempty object')
        for value, cfg in status['values'].items():
            _text(value, 'status value')
            _fields(cfg, {'palette_index','shape'}, {'palette_index','shape'}, 'status value')
            _text(cfg['palette_index'], 'status palette_index')
            ref.require(cfg['shape'] in ('circle','diamond'), 'status shape must be circle or diamond')
        ref.require(all(row[status['column']] in status['values'] for row in rows), 'unknown status value')
    cfg = style.get('components',{}).get('table_grouped',{})
    _fields(cfg, {'group_height_px','header_height_px','row_height_px','cell_padding_px'}, set(), 'style.components.table_grouped')
    label_role = resolve_role(style, style.get('components',{}).get('table',{}).get('text_role','label'))
    caption_role = resolve_role(style, 'caption')
    font, caption_font = label_role.family, caption_role.family
    size, small = label_role.size, caption_role.size
    padding = cfg.get('cell_padding_px',[8,16])
    ref.require(isinstance(padding,list) and len(padding) == 2 and all(_number(v,'cell padding') >= 0 and v % 8 == 0 for v in padding), 'cell_padding_px requires two nonnegative 8px multiples')
    top, side = padding
    module = lambda v: math.ceil(v/8)*8
    gh = cfg.get('group_height_px',module(small+2*top))
    hh = cfg.get('header_height_px',module(size+small+2*top+8))
    rh = cfg.get('row_height_px',module(size+2*top+(8 if bar_columns else 0)))
    for key,value,minimum in (('group height',gh,small+2*top),('header height',hh,size+small+2*top+8),('row height',rh,size+2*top+(8 if bar_columns else 0))):
        ref.require(_number(value,key) >= minimum and value % 8 == 0, f'{key}: insufficient height or not an 8px multiple')
    total = gh+hh+len(rows)*rh
    ref.require(total <= height, 'table rows exceed bounds height')
    palette = theme['palette']
    keys = {'accent1','accent2','surface_tint','lt1','lt2','dk1','dk2','line'}
    if status:
        keys.update(v['palette_index'] for v in status['values'].values())
    for key in keys:
        ref.require(isinstance(key,str) and key in palette and isinstance(palette[key],str) and re.fullmatch(r'#[0-9a-fA-F]{6}',palette[key]), f'unknown/invalid palette index: {key}')
    outer = ET.Element('{'+SVG+'}g', {'id':component_id,'data-component-kind':'table','data-component-variant':'grouped'})
    source = _node(outer,'metadata',type='application/json')
    marks = []
    marker = _node(outer,'g',id=component_id+'-native',data_pptx_replace_with='table')
    metadata = _node(marker,'metadata',type='application/json')
    marker.set('data-component-source',json.dumps(data,ensure_ascii=False,allow_nan=False))
    fallback = _node(marker,'g',id=component_id+'-fallback')
    none = lambda: {s:{'style':'none'} for s in ('top','bottom','left','right')}
    table_rows = ['']*count
    for i,group in enumerate(groups):
        start,span = group['start'],group['span']; gx=x+sum(widths[:start]); gw=sum(widths[start:start+span])
        fill = palette['accent1' if i%2 == 0 else 'accent2']
        _fit(group['label'],gw-2*side,small,'group header')
        cell = {'paragraphs':[{'align':'ctr','runs':[{'text':group['label'],'font_size':small,'font_family':caption_font,'bold':caption_role.bold,'color':palette['lt1']}]}],'fill':fill,'color':palette['lt1'],'font_size':small,'bold':caption_role.bold,'align':'ctr','valign':'middle','padding':{'top':0,'bottom':0,'left':side,'right':side},'borders':none()}
        if span > 1: cell['col_span']=span
        table_rows[start]=cell
        _node(fallback,'rect',x=gx,y=y,width=gw,height=gh,fill=fill)
        _label(fallback,group['label'],gx+gw/2,y+(gh+small*.72)/2,caption_font,small,palette['lt1'],'ctr',caption_role.svg_weight)
    table_rows = [table_rows]
    group_ends = {g['start']+g['span']-1 for g in groups[:-1]}
    cy = y+gh
    for ri,row in enumerate([columns,*rows]):
        header = ri == 0; focused = not header and ri-1 == focus; cell_height = hh if header else rh
        cx=x; cells=[]
        for ci,value in enumerate(row):
            fill = palette['surface_tint'] if header or focused else palette['lt2'] if ci in row_headers or ri%2 == 0 else palette['lt1']
            color = palette['accent1'] if header or focused else palette['dk1']
            if not header and ci not in numeric and ci not in row_headers: color=palette['dk2']
            is_status = not header and status is not None and ci == status['column']
            if is_status: color=palette[status['values'][value]['palette_index']]
            align='r' if ci in numeric else 'l'
            pad={'top':top,'bottom':top+8 if not header and ci in bar_columns else top,'left':side+32 if is_status else side,'right':side}
            borders=none(); borders['bottom']={'style':'solid','color':palette['accent1'] if focused else palette['line'],'width':1}
            if ci in group_ends: borders['right']={'style':'solid','color':palette['line'],'width':1}
            if focused:
                borders['top']={'style':'solid','color':palette['accent1'],'width':1}
                if ci == 0: borders['left']={'style':'solid','color':palette['accent1'],'width':4}
            cell={'fill':fill,'color':color,'align':align,'font_family':font,'font_size':size,'bold':label_role.bold,'padding':pad,'valign':'middle','borders':borders}
            _node(fallback,'rect',x=cx,y=cy,width=widths[ci],height=cell_height,fill=fill)
            tx=cx+widths[ci]-side if align == 'r' else cx+pad['left']
            if header:
                title,unit=value['label'],value.get('unit','')
                _fit(title,widths[ci]-2*side,size,'column header')
                cell['paragraphs']=[{'align':align,'runs':[{'text':title,'font_size':size,'font_family':font,'bold':label_role.bold,'color':color}]}]
                if unit:
                    _fit(unit,widths[ci]-2*side,small,'column unit')
                    cell['paragraphs'].append({'align':align,'runs':[{'text':unit,'font_size':small,'font_family':caption_font,'bold':caption_role.bold,'color':palette['dk2']}]})
                    baseline=cy+(cell_height-size-small-8)/2+size*.8
                    _label(fallback,title,tx,baseline,font,size,color,align,label_role.svg_weight)
                    _label(fallback,unit,tx,baseline+small+8,caption_font,small,palette['dk2'],align,caption_role.svg_weight)
                else: _label(fallback,title,tx,cy+(cell_height+size*.72)/2,font,size,color,align,label_role.svg_weight)
            else:
                displayed=_formatted(value,columns[ci]); cell['text']=displayed
                _fit(displayed,widths[ci]-pad['left']-side,size,'table cell')
                _label(fallback,displayed,tx,cy+(cell_height+size*.72-(8 if ci in bar_columns else 0))/2,font,size,color,align,label_role.svg_weight)
                if ci in bar_columns:
                    maximum=max(r[ci] for r in rows) or 1; track=widths[ci]-2*side
                    marks.append({'id':f'{component_id}-bar-r{ri}-c{ci}','kind':'bar','x':cx+side,'y':cy+cell_height-12,'width':track,'length':track*(value/maximum),'value':value,'domain':[0,maximum],'column':ci,'row':ri-1,'focused':focused})
                if is_status:
                    marks.append({'id':f'{component_id}-status-r{ri}-c{ci}','kind':'status','x':cx+side+8,'y':cy+cell_height/2,'palette_index':status['values'][value]['palette_index'],'shape':status['values'][value]['shape'],'value':value,'row':ri-1,'column':ci})
            for edge,line in borders.items():
                if line['style']=='none': continue
                coords={'top':(cx,cy,cx+widths[ci],cy),'bottom':(cx,cy+cell_height,cx+widths[ci],cy+cell_height),'left':(cx,cy,cx,cy+cell_height),'right':(cx+widths[ci],cy,cx+widths[ci],cy+cell_height)}[edge]
                _node(fallback,'line',x1=coords[0],y1=coords[1],x2=coords[2],y2=coords[3],stroke=line['color'],stroke_width=line['width'])
            cells.append(cell); cx+=widths[ci]
        table_rows.append(cells); cy+=cell_height
    payload={'name':component_id,'x':x,'y':y,'width':width,'height':total,'rows':table_rows,'header_rows':2,'strict_grid':True,'column_widths':widths,'row_heights':[gh,hh,*[rh]*len(rows)],'style':{'font_family':font,'font_size':size,'header_font_size':size,'band_row':False}}
    metadata.text=json.dumps(payload,ensure_ascii=False,allow_nan=False)
    source.text=json.dumps({'component_id':component_id,'data':data,'derived_marks':marks},ensure_ascii=False,allow_nan=False)
    runtime=Path(__file__).resolve().parent.parent/'runtime/ppt-master/scripts'
    if str(runtime) not in sys.path: sys.path.insert(0,str(runtime))
    from pptx_shapes import NATIVE_FALLBACK_SHA256_ATTR, svg_native_fallback_fingerprint
    marker.set(NATIVE_FALLBACK_SHA256_ATTR,svg_native_fallback_fingerprint(marker))
    overlay=_node(outer,'g',id=component_id+'-marks')
    for mark in marks:
        if mark['kind']=='bar':
            _node(overlay,'rect',id=mark['id']+'-track',x=mark['x'],y=mark['y'],width=mark['width'],height=4,fill=palette['line'])
            if mark['length'] > 0:
                _node(overlay,'rect',id=mark['id'],x=mark['x'],y=mark['y'],width=mark['length'],height=4,fill=palette['accent1'],fill_opacity=.8 if mark['focused'] else .4)
        elif mark['shape']=='circle': _node(overlay,'circle',id=mark['id'],cx=mark['x'],cy=mark['y'],r=4,fill=palette[mark['palette_index']])
        else:
            mx,my=mark['x'],mark['y']
            _node(overlay,'path',id=mark['id'],d=f'M {mx} {my-6} L {mx+6} {my} L {mx} {my+6} L {mx-6} {my} Z',fill=palette[mark['palette_index']])
    return outer