import json, os, hashlib, logging
from typing import List, Dict, Optional

log = logging.getLogger(__name__)

# --- real data source: code ---
TV_DATASET = None
HF_CANDIDATES = ['code_search_net', 'codeparrot/github-code']
IMAGE_FIELD = None
TEXT_FIELD = 'func_code_string'
LABEL_FIELD = 'func_documentation_string'
PROMPT_TEMPLATE = 'a photo of a {label}'
DATASET_URL = 'https://huggingface.co/datasets/code_search_net'

def fetch_real_samples(max_samples=5000, cache_dir='./_cache'):
    # 本地没有数据时自动下载真实公开数据集: torchvision -> HuggingFace -> 手动说明
    out = []
    if TV_DATASET is not None:
        try:
            import torchvision
            ctor = getattr(torchvision.datasets, TV_DATASET)
            try:
                ds = ctor(root=cache_dir, split='train', download=True)
            except TypeError:
                try:
                    ds = ctor(root=cache_dir, train=True, download=True)
                except TypeError:
                    ds = ctor(root=cache_dir, download=True)
            classes = getattr(ds, 'classes', None)
            os.makedirs(os.path.join(cache_dir, 'tv'), exist_ok=True)
            for i, item in enumerate(ds):
                if len(out) >= max_samples:
                    break
                img, label = item[0], item[1]
                name = classes[label] if classes else str(label)
                p = os.path.join(cache_dir, 'tv', str(i) + '.png')
                try:
                    img.save(p)
                except Exception:
                    continue
                out.append({'image': p, 'text': PROMPT_TEMPLATE.format(label=name)})
            if out:
                return out
        except Exception as e:
            print('torchvision load failed:', e)
    for repo in HF_CANDIDATES:
        try:
            from datasets import load_dataset
            try:
                ds = load_dataset(repo, split='train', streaming=True)
            except Exception:
                ds = load_dataset(repo, split='train')
            img_dir = os.path.join(cache_dir, 'hf_images')
            os.makedirs(img_dir, exist_ok=True)
            for i, ex in enumerate(ds):
                if len(out) >= max_samples:
                    break
                txt = None
                if TEXT_FIELD is not None and TEXT_FIELD in ex:
                    v = ex[TEXT_FIELD]
                    txt = v if isinstance(v, str) else ' '.join(map(str, v if isinstance(v, (list, tuple)) else [v]))
                if txt is None and LABEL_FIELD in ex:
                    txt = PROMPT_TEMPLATE.format(label=ex[LABEL_FIELD])
                if txt is None:
                    continue
                out.append({'text': txt})
            if out:
                return out
        except Exception as e:
            print('HF load failed for', repo, ':', e)
    print('Automatic download failed. Please get the data manually from:')
    print('   ' + DATASET_URL)
    return out


class CodeDataset:
    def __init__(self, data_dir: str, output_dir: str, img_size: int = 224):
        self.data_dir = data_dir
        self.output_dir = output_dir
        self.img_size = img_size
        self.samples = []
        self.processed = []

    def load(self) -> List[Dict]:
        # 加载
        from pathlib import Path
        for f in Path(self.data_dir).glob('*.jsonl'):
            with open(f) as fp:
                for line in fp:
                    if line.strip():
                        self.samples.append(json.loads(line))
        log.info(f'Loaded {len(self.samples)} samples')
        return self.samples

    def filter(self) -> List[Dict]:
        
        filtered = []
        for s in self.samples:
            text = s.get('code', s.get('text', ''))
            if len(text.split()) >= 3:
                filtered.append(s)
        self.samples = filtered
        return filtered

    def deduplicate(self) -> List[Dict]:
        seen = set()
        result = []
        for s in self.samples:
            fp = s.get('image', s.get('audio', ''))
            if fp and os.path.exists(fp):
                h = hashlib.md5(open(fp, 'rb').read()).hexdigest()
                if h in seen:
                    continue
                seen.add(h)
            result.append(s)
        self.samples = result
        return result

    def process(self) -> List[Dict]:
        os.makedirs(self.output_dir, exist_ok=True)
        for s in self.samples:
            item = {}
            if 'image' in s:
                try:
                    from PIL import Image
                    img = Image.open(s['image']).convert('RGB')
                    img = img.resize((self.img_size, self.img_size))
                    p = os.path.join(self.output_dir, os.path.basename(s['image']))
                    img.save(p, 'JPEG', quality=95)
                    item['image'] = p
                except Exception as e:
                    log.warning(f'Failed: {e}')
                    continue
            item['text'] = s.get('code', s.get('text', ''))
            item['domain'] = 'code'
            self.processed.append(item)
        return self.processed

    def save(self):
        path = os.path.join(self.output_dir, 'dataset.jsonl')
        with open(path, 'w') as f:
            for d in self.processed:
                f.write(json.dumps(d, ensure_ascii=False) + '\n')
        log.info(f'Saved {len(self.processed)} samples to {path}')

    def run(self):
        self.load()
        if not self.samples:
            self.samples = fetch_real_samples()
        self.filter()
        self.deduplicate()
        self.process()
        self.save()


if __name__ == '__main__':
    import sys
    ds = CodeDataset(sys.argv[1] if len(sys.argv) > 1 else './data',
                  sys.argv[2] if len(sys.argv) > 2 else './output')
    ds.run()