"""License-aware, non-executing extraction for the requested RAG sources."""
import ast
import hashlib
import re

from filter_core import inspect_code,template_hash,SECRET,INJECTION

VERSION='multi-source-v1'
PERMISSIVE={'MIT','Apache-2.0','BSD-2-Clause','BSD-3-Clause'}
HELPER_ROOTS={'os','sys','pathlib','warnings','pkg_resources','platform','logging'}


def sha(text):return hashlib.sha256(text.encode('utf-8')).hexdigest()


def license_header(code):
    """Only declarations before executable code; never infer MIT from a wrapper."""
    head=code[:20000]
    try:
        tree=ast.parse(code)
        first=next((n for n in tree.body if not (isinstance(n,ast.Expr) and isinstance(n.value,ast.Constant) and isinstance(n.value.value,str))),None)
        if first is not None:head='\n'.join(code.splitlines()[:first.lineno-1])[:20000]
    except (SyntaxError,ValueError,RecursionError):pass
    if re.search(r'GNU (?:GENERAL|LESSER|AFFERO)|\b[AL]?GPL[- v]|License-NC|Non.?Commercial|proprietary|all rights reserved.*no permission',head,re.I):
        return None,head,'restricted_or_unsupported_header'
    spdx=re.search(r'SPDX-License-Identifier:\s*([^\r\n]+)',head,re.I)
    if spdx:
        label=spdx.group(1).strip().strip('#*/ ')
        if label in PERMISSIVE:return label,head,'inline_spdx'
        return None,head,'unsupported_or_compound_spdx'
    if re.search(r'Licensed under (?:the )?Apache License[, ]*(?:Version )?2\.0|apache\.org/licenses/LICENSE-2\.0',head,re.I):
        return 'Apache-2.0',head,'inline_apache_notice'
    if re.search(r'Permission is hereby granted,? free of charge|Licensed under (?:the )?MIT License',head,re.I):
        return 'MIT',head,'inline_mit_notice'
    if re.search(r'Redistribution and use in source and binary forms',head,re.I) and re.search(r'THIS SOFTWARE IS PROVIDED',head,re.I):
        return ('BSD-3-Clause' if re.search(r'Neither the name|names? of.*contributors?',head,re.I) else 'BSD-2-Clause'),head,'inline_bsd_notice'
    return None,head,'no_inline_license'


def group_split(group):
    n=int(sha(group)[:8],16)%100
    return 'train' if n<80 else 'validation' if n<90 else 'test'


def import_nodes(tree):
    return [n for n in tree.body if isinstance(n,(ast.Import,ast.ImportFrom))]


def bound_imports(code,tree,unit):
    loaded={n.id for n in ast.walk(unit) if isinstance(n,ast.Name) and isinstance(n.ctx,ast.Load)}
    rows=[]
    for n in import_nodes(tree):
        names={(a.asname or a.name.split('.')[0]) for a in n.names}
        if names&loaded or isinstance(n,ast.ImportFrom) and n.module=='__future__':
            text=ast.get_source_segment(code,n)
            if text not in rows:rows.append(text)
    return '\n'.join(rows)


def raw_segment(code,node):
    start=min([node.lineno]+[x.lineno for x in getattr(node,'decorator_list',[])])
    return '\n'.join(code.splitlines()[start-1:node.end_lineno])


def units(code):
    """Complete AST statements/functions/classes, including decorators."""
    tree=ast.parse(code);items=[];batch=[];chars=0
    def flush():
        nonlocal batch,chars
        if batch:
            a=batch[0];b=batch[-1];segment='\n'.join(code.splitlines()[a.lineno-1:b.end_lineno])
            imports=bound_imports(code,tree,ast.Module(body=batch,type_ignores=[]))
            items.append(('top_level_statements',segment,imports,a.lineno,b.end_lineno,False))
            batch=[];chars=0
    for n in tree.body:
        if isinstance(n,(ast.Import,ast.ImportFrom)):continue
        if isinstance(n,ast.Expr) and isinstance(n.value,ast.Constant) and isinstance(n.value.value,str):continue
        if isinstance(n,(ast.FunctionDef,ast.AsyncFunctionDef,ast.ClassDef)):
            flush();segment=raw_segment(code,n)
            if len(segment)<=4800:
                items.append((n.name,segment,bound_imports(code,tree,n),n.lineno,n.end_lineno,False))
            elif isinstance(n,ast.ClassDef):
                for m in n.body:
                    if isinstance(m,(ast.FunctionDef,ast.AsyncFunctionDef)):
                        segment=raw_segment(code,m)
                        # Preserve method body while removing only class indentation.
                        import textwrap
                        segment=textwrap.dedent(segment)
                        if len(segment)<=4400:items.append((n.name+'.'+m.name,segment,bound_imports(code,tree,m),m.lineno,m.end_lineno,True))
            continue
        if isinstance(n,ast.If) and '__name__' in ast.unparse(n.test):flush();continue
        text=ast.get_source_segment(code,n)
        if batch and chars+len(text)>2600:flush()
        if len(text)<=4400:batch.append(n);chars+=len(text)
    flush()
    return tree,items


def analyze(code):
    info,reason=inspect_code(code)
    if reason:return None,reason
    calls=[c for c in info['calls'] if c and not c.startswith('.') and c.split('.')[0] not in HELPER_ROOTS]
    torch_calls=[c for c in calls if c.startswith('torch.') and not c.startswith(('torch.cuda.is_available','torch.cuda.device_count','torch.cuda.get_device','torch.backends.','torch.version'))]
    topics=set(info['topics'])
    if torch_calls:topics.add('pytorch')
    if any(c.endswith(('cross_entropy','nll_loss','mse_loss','binary_cross_entropy_with_logits')) for c in calls):topics.add('loss_functions')
    if any(c.endswith(('backward','zero_grad','step')) for c in calls) and (torch_calls or 'torch' in info['packages']):topics.add('training_loop')
    if any(c.endswith(('no_grad','inference_mode','eval')) for c in calls) and (torch_calls or 'torch' in info['packages']):topics.add('evaluation')
    if re.search(r'key_padding_mask|attention_mask|masked_fill|pad_sequence|pack_padded_sequence',code):topics.add('sequence_masking')
    if re.search(r'\.view\(|\.reshape\(|\.flatten\(|\.permute\(|\.transpose\(',code) and (torch_calls or 'torch' in info['packages']):topics.add('tensor_shapes')
    if not topics:return None,'not_useful_ml_operations'
    info['topics']=sorted(topics)
    return info,None


def code_records(code,meta,counters,default_license=None,require_inline=False):
    if not isinstance(code,str) or not 30<=len(code)<=250000:
        counters['code_bounds']+=1;return []
    if SECRET.search(code) or INJECTION.search(code):counters['unsafe_text']+=1;return []
    declared,notice,evidence=license_header(code)
    if evidence in {'restricted_or_unsupported_header','unsupported_or_compound_spdx'}:
        counters[evidence]+=1;return []
    license_id=declared or (None if require_inline else default_license)
    if not license_id:counters['missing_original_license_evidence']+=1;return []
    try:tree,parts=units(code)
    except (SyntaxError,ValueError,RecursionError):counters['syntax_error']+=1;return []
    records=[]
    for symbol,segment,imports,start,end,method in parts:
        full=(imports+'\n\n' if imports else '')+segment
        if len(full)>4800:counters['chunk_bounds']+=1;continue
        info,reason=analyze(full)
        if reason:counters[reason]+=1;continue
        flags=[]
        if method:flags.append('requires_class_context')
        if info['unresolved_names']:flags.append('requires_prior_state_or_project_modules')
        if any(n.startswith('_') for n in info['packages']):flags.append('private_or_project_module')
        if re.search(r'\.cuda\(|[\"\']cuda(?::\d+)?[\"\']',full):flags.append('cuda_referenced')
        if re.search(r'from_pretrained|pretrained\s*=\s*True|weights\s*=\s*(?:[A-Za-z_]+\.)?[A-Za-z_]+\.DEFAULT',full):flags.append('external_weights_required')
        if '.toarray(' in full:flags.append('densifies_sparse_matrix')
        if 'filterwarnings' in full:flags.append('suppresses_warnings')
        if meta.get('upstream_track')=='main':flags.append('main_snapshot_not_runtime_verified')
        ast_hash=sha(info['canonical']);template=template_hash(info['tree'])
        record={**meta,'record_id':meta['source_id']+'-'+sha(meta['source_path']+':'+str(meta.get('source_row',''))+':'+str(start)+':'+ast_hash)[:24],
            'record_type':'python_code','intended_use':'rag','split':group_split(meta['source_id']+':'+meta['source_group']),
            'symbol':symbol,'line_start':start,'line_end':end,'code':full,'code_sha256':sha(full),
            'ast_sha256':ast_hash,'template_ast_sha256':template,'topics':info['topics'],'packages':info['packages'],
            'unresolved_names':info['unresolved_names'],'external_data_required':info['external_data_required'],
            'compatibility_flags':flags,'license_id':license_id,'license_evidence':evidence if declared else 'upstream_repository_license',
            'attribution_notice':notice,'validated_here':'syntax_only_not_executed','benchmark_content':False,'curation_version':VERSION}
        record['text']=('# '+symbol+'\nSource: '+meta['source_url']+'#L'+str(start)+'-L'+str(end)+'\n'
            +'License: '+license_id+'. Syntax checked only; may require original state/files.\n'
            +('Flags: '+', '.join(flags)+'\n' if flags else '')+'\n```python\n'+full+'\n```\n')
        records.append(record)
    return records


def doc_records(text,meta,license_id,counters):
    if not isinstance(text,str) or len(text)>100000:return []
    if SECRET.search(text) or INJECTION.search(text):counters['unsafe_doc']+=1;return []
    text=re.sub(r'(?ms)^```[^\n]*\n.*?^```\s*$','',text)
    text=re.sub(r'(?m)^\.\. (?:code-block|code|literalinclude)::[^\n]*\n(?:\n|[ \t]+[^\n]*\n)*','',text)
    # Full paragraphs; omit shell/install directives rather than executing them.
    paragraphs=re.split(r'\n\s*\n',text);groups=[];parts=[];length=0
    for paragraph in paragraphs:
        if re.search(r'pip install|git clone|curl .*https?://|wget |sudo |\.sh\b',paragraph):continue
        if len(paragraph)>3800:continue
        if parts and length+len(paragraph)>2800:groups.append('\n\n'.join(parts));parts=[];length=0
        parts.append(paragraph);length+=len(paragraph)
    if parts:groups.append('\n\n'.join(parts))
    rows=[]
    for i,body in enumerate(groups):
        if len(body)<120 or not re.search(r'(?i)pytorch|torchvision|convolution|gradient|optim|training|segmentation|classification|tensor|attention|padding|normaliz|backprop',body):continue
        record={**meta,'record_id':meta['source_id']+'-doc-'+sha(meta['source_path']+':'+str(i)+body)[:24],
            'record_type':'documentation','intended_use':'rag','split':group_split(meta['source_id']+':'+meta['source_group']),
            'symbol':'documentation','line_start':0,'line_end':0,'code':'','code_sha256':'','ast_sha256':'','template_ast_sha256':'',
            'topics':['pytorch','documentation'],'packages':[],'unresolved_names':[],'external_data_required':False,
            'compatibility_flags':['not_runtime_verified'],'license_id':license_id,'license_evidence':'upstream_repository_license',
            'attribution_notice':'See the source folder LICENSE and ATTRIBUTIONS.jsonl.',
            'validated_here':'text_only_not_executed','benchmark_content':False,'curation_version':VERSION}
        record['text']='# Documentation excerpt\nSource: '+meta['source_url']+'\nLicense: '+license_id+'\n\n'+body
        rows.append(record)
    return rows


def evaluation_record(meta,case_id,text,license_id,code='',extra=None):
    if SECRET.search(text+'\n'+code) or INJECTION.search(text+'\n'+code):return None
    if len(text)>8000:text=text[:8000]+'\n[Metadata excerpt bounded; use upstream source for full case.]'
    info=None
    if code:
        if len(code)>4800:return None
        info,reason=analyze(code)
        if reason:return None
    row={**meta,'record_id':meta['source_id']+'-case-'+sha(case_id+':'+meta['source_path']+code)[:24],
        'record_type':'benchmark_reproducer' if code else 'benchmark_task','intended_use':'evaluation',
        'split':'test','symbol':case_id,'line_start':1 if code else 0,'line_end':len(code.splitlines()),
        'code':code,'code_sha256':sha(code) if code else '',
        'ast_sha256':sha(info['canonical']) if info else '',
        'template_ast_sha256':template_hash(info['tree']) if info else '',
        'topics':sorted(set((info['topics'] if info else [])+['benchmark','debugging'])),
        'packages':info['packages'] if info else [],'unresolved_names':info['unresolved_names'] if info else [],
        'external_data_required':True,'compatibility_flags':['intentionally_failing_or_task_specific','requires_original_benchmark_environment'],
        'license_id':license_id,'license_evidence':'upstream_benchmark_packaging_license',
        'attribution_notice':'See source LICENSE and NOTICE. Original linked repositories and issue reports retain their own licenses.',
        'validated_here':'syntax_only_not_executed' if code else 'metadata_only_not_executed',
        'benchmark_content':True,'curation_version':VERSION}
    row['text']='# Benchmark study/evaluation evidence — not a working recipe\n'+text+'\n\nSource: '+meta['source_url']+'\nLicense: '+license_id
    if code:row['text']+='\n\n```python\n'+code+'\n```\n'
    if extra:row.update(extra)
    return row