import os
import re
import glob
import json
import argparse
import random
import uuid
from tqdm import tqdm
from pathlib import Path
from collections import defaultdict

def parse_ground_truth(name):
    """Extract ground truth rotation axis and angle from filename or folder name"""
    # Remove file extension if present
    basename = name.split(".")[0] if "." in name else name
    
    parts = basename.split("_")
    if len(parts) >= 4:  # figXXXX_XXX_axis_angle
        rotation_axis = parts[-2]  # Second to last element is axis
        rotation_angle = int(parts[-1])  # Last element is angle
        
        # Convert negative angles to 0-360 range
        if rotation_angle < 0:
            rotation_angle += 360
            
        return rotation_axis, rotation_angle
    
    print(f"Warning: Could not parse name: {basename}")
    return None, None

def load_examples(example_dir, generation_mode):
    """Load example images from the example directory"""
    if generation_mode == "combined":
        # Load all single PNG files from the example directory
        files = glob.glob(os.path.join(example_dir, "*.png"))
        print(f"Found {len(files)} combined example images in {example_dir}")
        return files
    else:  # separate mode
        # Find all folders in the example directory
        folders = [f for f in glob.glob(os.path.join(example_dir, "*")) if os.path.isdir(f)]
        # Filter folders that contain both _ini.png and _rot.png files
        valid_folders = []
        for folder in folders:
            folder_name = os.path.basename(folder)
            ini_file = os.path.join(folder, f"{folder_name}_ini.png")
            rot_file = os.path.join(folder, f"{folder_name}_rot.png")
            if os.path.exists(ini_file) and os.path.exists(rot_file):
                valid_folders.append(folder)
        
        print(f"Found {len(valid_folders)} example folder pairs in {example_dir}")
        return valid_folders

def organize_examples(examples, generation_mode):
    """Organize examples by rotation axis and angle"""
    organized = defaultdict(list)
    for example in examples:
        basename = os.path.basename(example)
        if generation_mode == "combined":
            basename = basename.split(".")[0]
            
        axis, angle = parse_ground_truth(basename)
        if axis is None or angle is None:
            continue
            
        key = (axis, angle)
        organized[key].append(example)
    
    # Print statistics
    print("\nDistribution of examples by axis-angle:")
    for key, examples_list in organized.items():
        print(f"  {key[0]}-axis, {key[1]} degrees: {len(examples_list)} examples")
    
    return dict(organized)

def select_example(organized_examples, test_axis):
    """Select a single random example for the test case"""
    # Collect all examples for this axis regardless of angle
    all_examples_for_axis = []
    for (axis, angle), example_list in organized_examples.items():
        if axis == test_axis:
            for example in example_list:
                all_examples_for_axis.append((example, angle))
    
    # If we have any examples for this axis, select one randomly
    if all_examples_for_axis and len(all_examples_for_axis) > 0:
        return random.choice(all_examples_for_axis)
    else:
        print(f"Warning: No examples found for rotation around {test_axis}-axis")
        return None

def construct_prompt_with_example(axis, angle_increment, example=None, difficulty="easy", generation_mode="combined"):
    """Create prompt for the VLM with an in-context example"""
    # Generate list of all possible rotation angles based on angle increment
    possible_angles = []
    current_angle = 0 + angle_increment
    while current_angle < 360:
        possible_angles.append(current_angle)
        current_angle += angle_increment
    
    # Common instructions for both modes
    coordinate_system = (
        f"The 3D Cartesian coordinate system is defined as follows: "
        f"\n- x-axis: points horizontally from left to right (positive direction is right)"
        f"\n- y-axis: points vertically from bottom to top (positive direction is up)"
        f"\n- z-axis: points from inside the image toward the viewer (positive direction is out of the screen)"
        f"\n\nWhen discussing rotations around an axis, imagine looking along the positive direction of that axis (as if looking from the origin toward the positive end)."
    )
    
    angle_constraints = (
        f"The rotation angle is always a multiple of {angle_increment} degrees between 0 and 360 degrees inclusive. "
        f"A positive angle means rotation in the CLOCKWISE direction when looking along the positive direction of the axis. "
    )
    
    # Add example text if an example is provided
    example_text = ""
    if example:
        _, example_angle = example
        if generation_mode == "combined":
            example_text = f"\n### EXAMPLE OF ROTATION ###\n\nExample: Image 1 shows a 3D object with its left half showing the initial view and right half showing a {example_angle} degree rotation around the {axis}-axis.\n"
        else:  # separate mode
            example_text = f"\n### EXAMPLE OF ROTATION ###\n\nExample: Image 1 shows the initial view and Image 2 shows the object after a {example_angle} degree rotation around the {axis}-axis.\n"
    
    # Different instructions based on difficulty
    if difficulty == "easy":
        # For easy mode - axis is provided, internal reasoning but only output number
        thinking_instructions = (
            f"IMPORTANT: Please follow this systematic approach to determine the rotation angle:"
            f"\n\n1. First, analyze the object's features in both views to understand its structure."
            f"\n\n2. For the {axis}-axis rotation, you must evaluate ALL of these possible rotation angles: {possible_angles}"
            f"\n   - For each angle in the list, mentally visualize what the object would look like after rotating around the {axis}-axis by that amount"
            f"\n   - Compare these visualizations with the actual second view"
            f"\n   - DO NOT make a decision until you have evaluated all possible angles in the list"
            f"\n\n3. After evaluating all angles, choose the one that best matches the observed changes"
            f"\n\n4. Verify your answer by mentally applying the rotation to confirm it matches the second view"
        )
        
        # Updated response format to match rot_pred_sft.py
        response_format = (
            f"IMPORTANT: You must ONLY output the rotation angle as a number from this list: {possible_angles}. "
            f"Your output should contain ONLY the number. "
            f"Do NOT include any reasoning, explanation, or additional text - ONLY the number."
            f"\n\nExample of correct output format: 30"
            f"\n\nIncorrect output formats:"
            f"\n\"I think it's 30 degrees\""
            f"\n\"The rotation angle is 30\""
            f"\n\"30 degrees\""
        )
        
        task_description = (
            f"Your task is to determine the angle of rotation around the {axis}-axis in degrees."
        )
        
    else:  # hard mode - axis is not provided
        thinking_instructions = (
            f"IMPORTANT: Please follow this systematic approach to determine the rotation:"
            f"\n\n1. First, analyze the object's features in both views to understand its structure."
            f"\n\n2. Consider what would happen if rotation occurred around each of the three axes (x, y, and z):"
            f"\n   - For x-axis rotation: What specific features would change and how?"
            f"\n   - For y-axis rotation: What specific features would change and how?"
            f"\n   - For z-axis rotation: What specific features would change and how?"
            f"\n   - Based on the observed changes, explain which axis makes the most sense and why."
            f"\n\n3. Once you've determined the most likely axis, evaluate ALL of these possible rotation angles: {possible_angles}"
            f"\n   - For each angle in the list, describe what the object would look like after rotating around your chosen axis by that amount"
            f"\n   - Compare these descriptions with the actual second view"
            f"\n   - DO NOT make a decision until you have evaluated all angles in the list"
            f"\n\n4. After evaluating all angles, choose the one that best matches the observed changes"
        )
        
        response_format = (
            f"Place your detailed reasoning process in <thinking></thinking> tags. Your reasoning should include:"
            f"\n- Analysis of how rotation around each axis would affect the object"
            f"\n- Systematic evaluation of possible rotation angles from the provided list"
            f"\n- Specific visual features you used to determine your answer"
            f"\n\nThen provide your final answer in <rotation_axis></rotation_axis> and <rotation_angle></rotation_angle> tags respectively (use only x, y, or z for axis and only a number from the list for angle)."
            f"\ni.e., <thinking> your reasoning process here </thinking><rotation_axis> your predicted axis here </rotation_axis><rotation_angle> your predicted degrees here </rotation_angle>"
        )
        
        task_description = (
            f"Your task is to determine which axis the object was rotated around and by what angle."
        )
    
    # Generate the prompt based on generation mode
    if generation_mode == "combined":
        test_img_num = 2 if example else 1  # If we have an example, test image is #2
        prompt = (
            f"IMPORTANT: I'm showing you {2 if example else 1} image{'s' if example else ''} of 3D objects. "
            f"{'Each' if example else 'The'} image contains TWO separate 3D renderings side-by-side. "
            f"\n\nThe LEFT HALF shows a 3D object in its initial orientation. "
            f"The RIGHT HALF shows the SAME 3D object after being rotated."
            f"\n\n{task_description}"
            f"\n\n{coordinate_system}"
            f"\n\n{angle_constraints}"
            f"\n\n{example_text}"
            f"\n\n### YOUR TASK ###"
            f"\nNow, for Image {test_img_num}, determine the angle of rotation around the {axis}-axis."
            f"\n{'' if not example else 'Based on the example provided, '}analyze Image {test_img_num} carefully."
            f"\n\n{thinking_instructions}"
            f"\n\n{response_format}"
        )
    else:  # separate mode
        # Calculate image numbers based on examples
        test_img_start = 3 if example else 1  # If we have an example (2 images), test starts at #3
        test_img_end = 4 if example else 2
        prompt = (
            f"I'm showing you {4 if example else 2} images of 3D objects. "
            f"{'For each example or test case, ' if example else ''}two images represent the same object before and after rotation."
            f"\n\n{task_description}"
            f"\n\n{coordinate_system}"
            f"\n\n{angle_constraints}"
            f"\n\n{example_text}"
            f"\n\n### YOUR TASK ###"
            f"\nNow, determine the angle of rotation around the {axis}-axis from Image {test_img_start} to Image {test_img_end}."
            f"\n{'' if not example else 'Based on the example provided, '}analyze the rotation carefully."
            f"\n\n{thinking_instructions}"
            f"\n\n{response_format}"
        )
            
    return prompt

def create_metadata_jsonl_combined(input_dir, output_file, example_dir=None, angle_increment=30, difficulty="easy"):
    """Create metadata JSONL file for all images in input_dir (combined mode)"""
    # Get all PNG files in the input directory
    png_files = glob.glob(os.path.join(input_dir, "*.png"))
    
    # Sort files to ensure consistent order
    png_files = sorted(png_files)
    
    if not png_files:
        print(f"No PNG files found in {input_dir}")
        return
    
    print(f"Found {len(png_files)} PNG files in {input_dir}")
    
    # Load and organize examples if example_dir is provided
    organized_examples = None
    if example_dir:
        examples = load_examples(example_dir, "combined")
        organized_examples = organize_examples(examples, "combined")
    
    # Create output directory if it doesn't exist
    output_dir = os.path.dirname(output_file)
    os.makedirs(output_dir, exist_ok=True)
    
    # Process each file and create metadata entries
    entries = []
    
    for png_file in tqdm(png_files, desc="Creating metadata for combined mode"):
        # Parse ground truth from filename
        axis, angle = parse_ground_truth(os.path.basename(png_file))
        
        if axis is None or angle is None:
            print(f"Skipping {png_file} - could not parse ground truth")
            continue
        
        # Get the relative path to the image
        rel_path = os.path.relpath(png_file, os.path.dirname(output_file))
        
        # Generate a unique ID based on the filename
        image_base_id = os.path.splitext(os.path.basename(png_file))[0]
        
        # Select an example if examples are available
        example = None
        if organized_examples:
            example = select_example(organized_examples, axis)
        
        # Construct prompt with or without example
        prompt = construct_prompt_with_example(axis, angle_increment, example, difficulty, generation_mode="combined")
        
        # Create assistant response based on difficulty
        if difficulty == "easy":
            # For easy mode, just output the number
            assistant_content = f"{angle}"
        else:
            # For hard mode, include both axis and angle in XML tags
            assistant_content = f"<thinking>Detailed reasoning about rotation axis and angle...</thinking><rotation_axis>{axis}</rotation_axis><rotation_angle>{angle}</rotation_angle>"
        
        # Create the conversations array
        conversations = []
        
        # Add human message with prompt and images
        human_value = ""
        
        # Add example image if available
        if example:
            example_path, _ = example
            example_rel_path = os.path.relpath(example_path, os.path.dirname(output_file))
            human_value += f"<image>{example_rel_path}</image>\n"
            
        # Add test image
        human_value += f"<image>{rel_path}</image>\n{prompt}"
        
        conversations.append({
            "from": "human",
            "value": human_value
        })
        
        # Add assistant response
        conversations.append({
            "from": "gpt",
            "value": assistant_content
        })
        
        # Create entry with the correct format
        entry = {
            "id": image_base_id,
            "image": rel_path,
            "conversations": conversations
        }
        
        entries.append(entry)
    
    # Write entries to JSONL file
    with open(output_file, 'w') as f:
        for entry in entries:
            f.write(json.dumps(entry) + '\n')
    
    print(f"\nSummary for combined mode:")
    print(f"  Found {len(png_files)} PNG files")
    print(f"  Created metadata for {len(entries)} entries")
    print(f"  Output file: {output_file}")

def create_metadata_jsonl_separate(input_dir, output_file, example_dir=None, angle_increment=30, difficulty="easy"):
    """Create metadata JSONL file for folders in input_dir (separate mode)"""
    # Get all directories in the input directory
    folders = [f for f in glob.glob(os.path.join(input_dir, "*")) 
              if os.path.isdir(f) and os.path.basename(f) != "examples"]
    
    # Sort folders to ensure consistent order
    folders = sorted(folders)
    
    if not folders:
        print(f"No folders found in {input_dir}")
        return
    
    print(f"Found {len(folders)} folders in {input_dir}")
    
    # Load and organize examples if example_dir is provided
    organized_examples = None
    if example_dir:
        examples = load_examples(example_dir, "separate")
        organized_examples = organize_examples(examples, "separate")
    
    # Create output directory if it doesn't exist
    output_dir = os.path.dirname(output_file)
    os.makedirs(output_dir, exist_ok=True)
    
    # Process each folder and create metadata entries
    entries = []
    valid_folders = 0
    
    for folder in tqdm(folders, desc="Creating metadata for separate mode"):
        folder_name = os.path.basename(folder)
        
        # Parse ground truth from folder name
        axis, angle = parse_ground_truth(folder_name)
        
        if axis is None or angle is None:
            print(f"Skipping {folder} - could not parse ground truth")
            continue
        
        # Check for the two required images in the folder
        ini_path = os.path.join(folder, f"{folder_name}_ini.png")
        rot_path = os.path.join(folder, f"{folder_name}_rot.png")
        
        if not os.path.exists(ini_path):
            print(f"Skipping {folder} - missing initial view image")
            continue
            
        if not os.path.exists(rot_path):
            print(f"Skipping {folder} - missing rotated view image")
            continue
        
        # Get the relative paths to the images
        rel_ini_path = os.path.relpath(ini_path, os.path.dirname(output_file))
        rel_rot_path = os.path.relpath(rot_path, os.path.dirname(output_file))
        
        # Select an example if examples are available
        example = None
        image_paths = []
        
        if organized_examples:
            example = select_example(organized_examples, axis)
        
        # Construct prompt with or without example
        prompt = construct_prompt_with_example(axis, angle_increment, example, difficulty, generation_mode="separate")
        
        # Create assistant response based on difficulty
        if difficulty == "easy":
            # For easy mode, just output the number
            assistant_content = f"{angle}"
        else:
            # For hard mode, include both axis and angle in XML tags
            assistant_content = f"<thinking>Detailed reasoning about rotation axis and angle...</thinking><rotation_axis>{axis}</rotation_axis><rotation_angle>{angle}</rotation_angle>"
        
        # Create the conversations array
        conversations = []
        
        # Prepare images array for the entry
        all_image_paths = []
        
        # Add example images if available
        if example:
            example_folder, _ = example
            example_folder_name = os.path.basename(example_folder)
            example_ini_path = os.path.join(example_folder, f"{example_folder_name}_ini.png")
            example_rot_path = os.path.join(example_folder, f"{example_folder_name}_rot.png")
            
            example_rel_ini_path = os.path.relpath(example_ini_path, os.path.dirname(output_file))
            example_rel_rot_path = os.path.relpath(example_rot_path, os.path.dirname(output_file))
            
            all_image_paths.append(example_rel_ini_path)
            all_image_paths.append(example_rel_rot_path)
        
        # Add test images
        all_image_paths.append(rel_ini_path)
        all_image_paths.append(rel_rot_path)
        
        # Add human message with prompt and images - format with <image> tags at the beginning
        human_value = "<image>\n<image>\n<image>\n<image>\n" + prompt
        
        conversations.append({
            "from": "human",
            "value": human_value
        })
        
        # Add assistant response
        conversations.append({
            "from": "gpt",
            "value": assistant_content
        })
        
        # Create entry with the correct format
        entry = {
            "id": folder_name,
            "image": all_image_paths,
            "conversations": conversations
        }
        
        entries.append(entry)
        valid_folders += 1
    
    # Write entries to JSONL file
    with open(output_file, 'w') as f:
        for entry in entries:
            f.write(json.dumps(entry) + '\n')
    
    print(f"\nSummary for separate mode:")
    print(f"  Found {len(folders)} folders")
    print(f"  Created metadata for {valid_folders} valid folders")
    print(f"  Output file: {output_file}")
    
def main():
    parser = argparse.ArgumentParser(description="Create metadata JSONL for rotation dataset")
    parser.add_argument('--input-dir', type=str, required=True,
                      help="Directory containing rotation dataset images or folders")
    parser.add_argument('--output-file', type=str, default="metadata.jsonl",
                      help="Output JSONL file path")
    parser.add_argument('--example-dir', type=str, default=None,
                      help="Directory containing example images for in-context learning")
    parser.add_argument('--angle-increment', type=int, default=30,
                      help="Angle increment used in the dataset (e.g., 30, 45, 90)")
    parser.add_argument('--difficulty', type=str, choices=["easy", "hard"], default="easy",
                      help="Difficulty mode: easy (axis provided) or hard (axis not provided)")
    parser.add_argument('--generation-mode', type=str, choices=["combined", "separate"], default="combined",
                      help="Mode for dataset generation (combined = one image with both views, separate = folder with two images)")
    parser.add_argument('--random-seed', type=int, default=None,
                      help="Random seed for example selection (None for true randomness)")
    
    args = parser.parse_args()
    
    # Set random seed for reproducibility if provided
    if args.random_seed is not None:
        print(f"Using fixed random seed: {args.random_seed}")
        random.seed(args.random_seed)
    else:
        print("Using true randomness (different examples each run)")
    
    print(f"Creating metadata JSONL for rotation dataset:")
    print(f"Input directory: {args.input_dir}")
    print(f"Output file: {args.output_file}")
    
    if args.example_dir:
        print(f"Example directory: {args.example_dir}")
    
    print(f"Angle increment: {args.angle_increment} degrees")
    print(f"Difficulty mode: {args.difficulty}")
    print(f"Generation mode: {args.generation_mode}")
    
    # Check if example_dir is None but there's an 'examples' subdirectory in input_dir
    if args.example_dir is None and os.path.exists(os.path.join(args.input_dir, "examples")):
        args.example_dir = os.path.join(args.input_dir, "examples")
        print(f"Using examples directory: {args.example_dir}")
    
    if args.generation_mode == "combined":
        create_metadata_jsonl_combined(
            input_dir=args.input_dir,
            output_file=args.output_file,
            example_dir=args.example_dir,
            angle_increment=args.angle_increment,
            difficulty=args.difficulty
        )
    else:  # separate mode
        create_metadata_jsonl_separate(
            input_dir=args.input_dir,
            output_file=args.output_file,
            example_dir=args.example_dir,
            angle_increment=args.angle_increment,
            difficulty=args.difficulty
        )

if __name__ == "__main__":
    main()