{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e1c4573",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '../..')))\n",
    "\n",
    "# Path Configuration\n",
    "from tools.preprocess import *\n",
    "\n",
    "# Processing context\n",
    "trait = \"Liver_Cancer\"\n",
    "cohort = \"GSE174570\"\n",
    "\n",
    "# Input paths\n",
    "in_trait_dir = \"../../input/GEO/Liver_Cancer\"\n",
    "in_cohort_dir = \"../../input/GEO/Liver_Cancer/GSE174570\"\n",
    "\n",
    "# Output paths\n",
    "out_data_file = \"../../output/preprocess/Liver_Cancer/GSE174570.csv\"\n",
    "out_gene_data_file = \"../../output/preprocess/Liver_Cancer/gene_data/GSE174570.csv\"\n",
    "out_clinical_data_file = \"../../output/preprocess/Liver_Cancer/clinical_data/GSE174570.csv\"\n",
    "json_path = \"../../output/preprocess/Liver_Cancer/cohort_info.json\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0681b357",
   "metadata": {},
   "source": [
    "### Step 1: Initial Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "047ffd1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tools.preprocess import *\n",
    "# 1. Identify the paths to the SOFT file and the matrix file\n",
    "soft_file, matrix_file = geo_get_relevant_filepaths(in_cohort_dir)\n",
    "\n",
    "# 2. Read the matrix file to obtain background information and sample characteristics data\n",
    "background_prefixes = ['!Series_title', '!Series_summary', '!Series_overall_design']\n",
    "clinical_prefixes = ['!Sample_geo_accession', '!Sample_characteristics_ch1']\n",
    "background_info, clinical_data = get_background_and_clinical_data(matrix_file, background_prefixes, clinical_prefixes)\n",
    "\n",
    "# 3. Obtain the sample characteristics dictionary from the clinical dataframe\n",
    "sample_characteristics_dict = get_unique_values_by_row(clinical_data)\n",
    "\n",
    "# 4. Explicitly print out all the background information and the sample characteristics dictionary\n",
    "print(\"Background Information:\")\n",
    "print(background_info)\n",
    "print(\"Sample Characteristics Dictionary:\")\n",
    "print(sample_characteristics_dict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "786ffa37",
   "metadata": {},
   "source": [
    "### Step 2: Dataset Analysis and Clinical Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04691b9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define variables for gene expression and trait data availability\n",
    "is_gene_available = True  # The dataset appears to have gene expression data from Human Genome U219 Array\n",
    "trait_row = 0  # The disease state (HCC) is in row 0\n",
    "age_row = None  # Age information is not available\n",
    "gender_row = None  # Gender information is not available\n",
    "\n",
    "# Define conversion functions for trait\n",
    "def convert_trait(value):\n",
    "    if value is None:\n",
    "        return None\n",
    "    # Extract value after colon if present\n",
    "    if ':' in value:\n",
    "        value = value.split(':', 1)[1].strip()\n",
    "    \n",
    "    # Convert to binary (1 for HCC, 0 for non-HCC/normal)\n",
    "    if 'HCC' in value:\n",
    "        return 1\n",
    "    elif 'non' in value.lower() or 'normal' in value.lower() or 'control' in value.lower():\n",
    "        return 0\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "# Define placeholder conversion functions for age and gender\n",
    "def convert_age(value):\n",
    "    return None  # Age data is not available\n",
    "\n",
    "def convert_gender(value):\n",
    "    return None  # Gender data is not available\n",
    "\n",
    "# Check if trait data is available\n",
    "is_trait_available = trait_row is not None\n",
    "\n",
    "# Save metadata using the validate_and_save_cohort_info function\n",
    "validate_and_save_cohort_info(\n",
    "    is_final=False,\n",
    "    cohort=cohort,\n",
    "    info_path=json_path,\n",
    "    is_gene_available=is_gene_available,\n",
    "    is_trait_available=is_trait_available\n",
    ")\n",
    "\n",
    "# If trait data is available, extract clinical features\n",
    "if trait_row is not None:\n",
    "    try:\n",
    "        # Convert the sample characteristics dictionary to a DataFrame\n",
    "        # This is assuming the sample_characteristics dictionary from the previous output is available\n",
    "        # For example: {0: ['disease state: HCC'], 1: ['tissue: Tumour (liver)', 'tissue: Non-tumour adjacent (liver)']}\n",
    "        sample_characteristics = {\n",
    "            0: ['disease state: HCC'], \n",
    "            1: ['tissue: Tumour (liver)', 'tissue: Non-tumour adjacent (liver)']\n",
    "        }\n",
    "        \n",
    "        # Create a DataFrame from the sample characteristics\n",
    "        # Convert dictionary to list of lists format for DataFrame\n",
    "        data = []\n",
    "        max_values = max(len(values) for values in sample_characteristics.values())\n",
    "        \n",
    "        for i in range(max_values):\n",
    "            row = []\n",
    "            for key in sorted(sample_characteristics.keys()):\n",
    "                if i < len(sample_characteristics[key]):\n",
    "                    row.append(sample_characteristics[key][i])\n",
    "                else:\n",
    "                    row.append(None)\n",
    "            data.append(row)\n",
    "        \n",
    "        clinical_data = pd.DataFrame(data)\n",
    "        \n",
    "        # Extract clinical features\n",
    "        selected_clinical_df = geo_select_clinical_features(\n",
    "            clinical_df=clinical_data,\n",
    "            trait=trait,\n",
    "            trait_row=trait_row,\n",
    "            convert_trait=convert_trait,\n",
    "            age_row=age_row,\n",
    "            convert_age=convert_age,\n",
    "            gender_row=gender_row,\n",
    "            convert_gender=convert_gender\n",
    "        )\n",
    "\n",
    "        # Preview the dataframe\n",
    "        preview = preview_df(selected_clinical_df)\n",
    "        print(\"Clinical DataFrame Preview:\")\n",
    "        print(preview)\n",
    "\n",
    "        # Save the clinical data\n",
    "        os.makedirs(os.path.dirname(out_clinical_data_file), exist_ok=True)\n",
    "        selected_clinical_df.to_csv(out_clinical_data_file, index=False)\n",
    "        print(f\"Clinical data saved to {out_clinical_data_file}\")\n",
    "    except Exception as e:\n",
    "        print(f\"Error processing clinical data: {e}\")\n",
    "else:\n",
    "    print(\"Trait data is not available. Skipping clinical feature extraction.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cedff717",
   "metadata": {},
   "source": [
    "### Step 3: Gene Data Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fdee207",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if the dataset contains gene expression data based on previous assessment\n",
    "if not is_gene_available:\n",
    "    print(\"This dataset does not contain gene expression data (only miRNA data).\")\n",
    "    print(\"Skipping gene expression data extraction.\")\n",
    "else:\n",
    "    # Get the matrix file directly rather than using geo_get_relevant_filepaths\n",
    "    files = os.listdir(in_cohort_dir)\n",
    "    if len(files) > 0:\n",
    "        matrix_file = os.path.join(in_cohort_dir, files[0])\n",
    "        print(f\"Matrix file found: {matrix_file}\")\n",
    "        \n",
    "        try:\n",
    "            # Extract gene data\n",
    "            gene_data = get_genetic_data(matrix_file)\n",
    "            print(f\"Gene data shape: {gene_data.shape}\")\n",
    "            \n",
    "            # Print the first 20 gene/probe identifiers\n",
    "            print(\"First 20 gene/probe identifiers:\")\n",
    "            print(gene_data.index[:20])\n",
    "        except Exception as e:\n",
    "            print(f\"Error extracting gene data: {e}\")\n",
    "    else:\n",
    "        print(\"No files found in the input directory.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcbad12e",
   "metadata": {},
   "source": [
    "### Step 4: Gene Identifier Review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fa4abbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These identifiers ('11715100_at', etc.) are Affymetrix probe IDs, not human gene symbols.\n",
    "# They need to be mapped to gene symbols for proper biological interpretation.\n",
    "# Affymetrix probe IDs are microarray-specific identifiers that need to be converted\n",
    "# to standard gene symbols for cross-platform analysis.\n",
    "\n",
    "requires_gene_mapping = True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3c2846c",
   "metadata": {},
   "source": [
    "### Step 5: Gene Annotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "417420cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Use the 'get_gene_annotation' function from the library to get gene annotation data from the SOFT file.\n",
    "soft_file, matrix_file = geo_get_relevant_filepaths(in_cohort_dir)\n",
    "gene_annotation = get_gene_annotation(soft_file)\n",
    "\n",
    "# 2. Analyze the gene annotation dataframe to identify which columns contain the gene identifiers and gene symbols\n",
    "print(\"\\nGene annotation preview:\")\n",
    "print(f\"Columns in gene annotation: {gene_annotation.columns.tolist()}\")\n",
    "print(preview_df(gene_annotation, n=5))\n",
    "\n",
    "# Look more closely at columns that might contain gene information\n",
    "print(\"\\nExamining potential gene mapping columns:\")\n",
    "potential_gene_columns = ['gene_assignment', 'mrna_assignment', 'swissprot', 'unigene']\n",
    "for col in potential_gene_columns:\n",
    "    if col in gene_annotation.columns:\n",
    "        print(f\"\\nSample values from '{col}' column:\")\n",
    "        print(gene_annotation[col].head(3).tolist())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "428d2020",
   "metadata": {},
   "source": [
    "### Step 6: Gene Identifier Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55df49dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Identify which columns contain the gene identifiers and gene symbols\n",
    "# From the previous output, we can see:\n",
    "# - The gene expression data uses Affymetrix probe IDs as identifiers (e.g., '11715100_at')\n",
    "# - In the gene annotation dataframe, the 'ID' column contains these same probe IDs\n",
    "# - The 'Gene Symbol' column contains the corresponding gene symbols\n",
    "\n",
    "# 2. Create a gene mapping dataframe using the appropriate columns\n",
    "prob_col = 'ID'  # Column with probe IDs\n",
    "gene_col = 'Gene Symbol'  # Column with gene symbols\n",
    "mapping_df = get_gene_mapping(gene_annotation, prob_col, gene_col)\n",
    "\n",
    "print(f\"\\nGene mapping dataframe shape: {mapping_df.shape}\")\n",
    "print(\"First few rows of the mapping dataframe:\")\n",
    "print(preview_df(mapping_df, n=5))\n",
    "\n",
    "# 3. Apply gene mapping to convert probe-level measurements to gene expression data\n",
    "gene_data = apply_gene_mapping(gene_data, mapping_df)\n",
    "\n",
    "print(f\"\\nGene expression dataframe after mapping - shape: {gene_data.shape}\")\n",
    "print(\"First few rows of the gene expression dataframe:\")\n",
    "print(preview_df(gene_data, n=5))\n",
    "\n",
    "# Save the gene expression data\n",
    "os.makedirs(os.path.dirname(out_gene_data_file), exist_ok=True)\n",
    "gene_data.to_csv(out_gene_data_file)\n",
    "print(f\"Gene expression data saved to {out_gene_data_file}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f204692c",
   "metadata": {},
   "source": [
    "### Step 7: Data Normalization and Linking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54020d09",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Normalize gene symbols in the index\n",
    "print(\"\\nNormalizing gene symbols...\")\n",
    "normalized_gene_data = normalize_gene_symbols_in_index(gene_data)\n",
    "print(f\"Gene data shape after normalization: {normalized_gene_data.shape}\")\n",
    "print(\"First 10 gene identifiers after normalization:\")\n",
    "print(normalized_gene_data.index[:10].tolist())\n",
    "\n",
    "# Save the normalized gene data to CSV\n",
    "os.makedirs(os.path.dirname(out_gene_data_file), exist_ok=True)\n",
    "normalized_gene_data.to_csv(out_gene_data_file)\n",
    "print(f\"Normalized gene data saved to {out_gene_data_file}\")\n",
    "\n",
    "# 2. Load the clinical data that was saved in step 2\n",
    "try:\n",
    "    clinical_df = pd.read_csv(out_clinical_data_file)\n",
    "    print(f\"Clinical data loaded from {out_clinical_data_file}\")\n",
    "    print(f\"Clinical data columns: {clinical_df.columns.tolist()}\")\n",
    "except Exception as e:\n",
    "    print(f\"Error loading clinical data: {e}\")\n",
    "    # Create a minimal clinical DataFrame based on our understanding from previous steps\n",
    "    clinical_df = pd.DataFrame({0: [1.0]})\n",
    "    print(\"Created basic clinical data as fallback\")\n",
    "\n",
    "# Check if the trait can be found in the clinical data columns\n",
    "if trait in clinical_df.columns:\n",
    "    trait_col_to_use = trait\n",
    "else:\n",
    "    # Use the first column as the trait column if available\n",
    "    trait_col_to_use = clinical_df.columns[0] if len(clinical_df.columns) > 0 else None\n",
    "    if trait_col_to_use is not None:\n",
    "        print(f\"Using column '{trait_col_to_use}' as trait column\")\n",
    "        # Rename for clarity in downstream processing\n",
    "        clinical_df = clinical_df.rename(columns={trait_col_to_use: trait})\n",
    "        trait_col_to_use = trait\n",
    "\n",
    "# Based on our analysis from Step 2, this dataset doesn't have appropriate trait data\n",
    "# for liver cancer comparison (all samples are cancer without controls)\n",
    "is_gene_available = len(normalized_gene_data) > 0\n",
    "is_trait_available = False  # We determined in Step 2 that there's no proper trait data for case/control comparison\n",
    "is_biased = True  # Since all samples are cancer cell lines, there's no control vs. cancer comparison\n",
    "\n",
    "# 5. Conduct final quality validation and save metadata\n",
    "print(\"\\nConducting final quality validation...\")\n",
    "note = \"This dataset contains gene expression data from human liver samples, but it lacks appropriate control vs. cancer comparison needed for liver cancer association studies. From background information, all samples appear to be from HCC without normal controls.\"\n",
    "\n",
    "# Create a minimal linked dataframe for validation purposes\n",
    "if trait_col_to_use is not None:\n",
    "    linked_data = pd.DataFrame({trait: clinical_df[trait].values})\n",
    "else:\n",
    "    linked_data = pd.DataFrame()  # Empty DataFrame if no trait column\n",
    "\n",
    "is_usable = validate_and_save_cohort_info(\n",
    "    is_final=True,\n",
    "    cohort=cohort,\n",
    "    info_path=json_path,\n",
    "    is_gene_available=is_gene_available,\n",
    "    is_trait_available=is_trait_available,\n",
    "    is_biased=is_biased,\n",
    "    df=linked_data,\n",
    "    note=note\n",
    ")\n",
    "\n",
    "# No need to save linked_data since the dataset is not usable for our trait analysis\n",
    "if is_usable:\n",
    "    # Link the clinical and genetic data for a proper dataset\n",
    "    linked_data = geo_link_clinical_genetic_data(clinical_df, normalized_gene_data)\n",
    "    \n",
    "    # Handle missing values if we have a trait column\n",
    "    if trait in linked_data.columns:\n",
    "        linked_data = handle_missing_values(linked_data, trait)\n",
    "    \n",
    "    os.makedirs(os.path.dirname(out_data_file), exist_ok=True)\n",
    "    linked_data.to_csv(out_data_file)\n",
    "    print(f\"Linked data saved to {out_data_file}\")\n",
    "else:\n",
    "    print(\"Linked data not saved as dataset is not usable for the current trait study.\")"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}