import json
import os
import logging
import argparse
from datasets import Dataset
import io

# Configure logging for detailed output
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def load_questions_from_meta_qa(meta_qa_file):
    with open(meta_qa_file, "r") as f:
        questions = [line.strip() for line in f if line.strip()]
    return questions

def process_parquet_files(data_dir, output_jsonl, meta_qa_file=None):
    """
    Process Parquet files to generate a JSONL file with QA list creation.
    
    Args:
        data_dir (str): Directory containing Parquet files.
        output_jsonl (str): Output JSONL file path.
        meta_qa_file (str, optional): Path to the meta_qa_en.txt file for QA list creation.
    
    Returns:
        None
    """

    # Load questions if meta_qa_file is provided
    questions = None
    if meta_qa_file:
        questions = load_questions_from_meta_qa(meta_qa_file)

    jsonl_data = []

    parquet_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) if f.endswith(".parquet")]

    for parquet_file in parquet_files:
        dataset = Dataset.from_parquet(parquet_file)

        for row in dataset:
            json_item = {
                "internal_id": row["internal_id"],
                "url": row["url"],
                "video_path": row["video_path"],
                "prompt": row["prompt"],
                "annotation": row["annotation"],
                "meta_result": row["meta_result"],
                "meta_mask": row["meta_mask"],
            }

            # Process QA pairs if questions are provided
            if questions:
                qa_list = []
                meta_result = row["meta_result"]
                meta_mask = row["meta_mask"]
                for idx, mask in enumerate(meta_mask):
                    if mask == 1:  # Add questions only if the mask is 1
                        question = questions[idx]
                        if "[[prompt]]" in question:
                            question = question.replace("[[prompt]]", row["prompt"])
                        answer = 'yes' if meta_result[idx] == 1 else 'no'
                        qa_list.append({"question": question, "answer": answer})
                json_item["qa_list"] = qa_list

            jsonl_data.append(json_item)

    with open(output_jsonl, "w") as outfile:
        for json_item in jsonl_data:
            outfile.write(json.dumps(json_item) + "\n")
    logger.info(f"Finished writing JSONL file with {len(jsonl_data)} items.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Convert Video dataset Parquet files to JSONL format with QA list generation.")
    parser.add_argument("--data_dir", type=str, default='train', help="Directory containing Parquet files.")
    parser.add_argument("--output_jsonl", type=str, default='annotation.jsonl', help="Path to the output JSONL file.")
    parser.add_argument("--meta_qa_file", type=str, default="meta_qa_en.txt", help="Optional: Path to the meta_qa_en.txt file for QA list generation.")
    args = parser.parse_args()

    process_parquet_files(
        data_dir=args.data_dir,
        output_jsonl=args.output_jsonl,
        meta_qa_file=args.meta_qa_file
    )