#!/bin/bash

# Script único de tracking automático de módulos con Airtable
# Uso: ./track-module.sh <module_name> "descripción del cambio"

MODULE_NAME=$1
DESCRIPTION=$2

# =============================================================================
# CONFIGURACIÓN DE AIRTABLE - MODIFICA AQUÍ TUS DATOS
# =============================================================================
AIRTABLE_API_KEY="patiXf0DmXaHBmoAm.ff9fca93e854cad97ad54f99b962d2cb061bcb2571525f05ad18c008a2b3b127"
AIRTABLE_BASE_ID="appVTbi2oO1FIvvkJ"
AIRTABLE_MODULES_TABLE="MODULOS"
AIRTABLE_PROJECTS_TABLE="PROYECTOS"
AIRTABLE_PROPAGATIONS_TABLE="PROPAGACIONES"

# =============================================================================
# CONFIGURACIÓN DE MÓDULOS - MAPEO DE NOMBRES
# =============================================================================
# Función para obtener el nombre de Airtable de un módulo
get_airtable_module_name() {
    local module_name=$1
    case $module_name in
        "gallery") echo "GALLERY IMAGE" ;;
        "blog") echo "BLOG" ;;
        "services") echo "SERVICES" ;;
        "products") echo "PRODUCTS" ;;
        "projects") echo "PROJECTS" ;;
        "team") echo "TEAM PROFILES" ;;
        "references") echo "REFERENCES" ;;
        "cd-base") echo "CD-BASE" ;;
        *) echo "" ;;
    esac
}

# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m'

# Función para logging
log_info() {
    echo -e "${BLUE}ℹ️  $1${NC}"
}

log_success() {
    echo -e "${GREEN}✅ $1${NC}"
}

log_warning() {
    echo -e "${YELLOW}⚠️  $1${NC}"
}

log_error() {
    echo -e "${RED}❌ $1${NC}"
}

log_step() {
    echo -e "${PURPLE}🔧 $1${NC}"
}

# Función para hacer requests a Airtable
airtable_request() {
    local method=$1
    local endpoint=$2
    local data=$3
    
    local url="https://api.airtable.com/v0/${AIRTABLE_BASE_ID}/${endpoint}"
    local headers=(
        "Authorization: Bearer ${AIRTABLE_API_KEY}"
        "Content-Type: application/json"
    )
    
    if [ "$method" = "GET" ]; then
        curl -s -H "${headers[0]}" -H "${headers[1]}" "$url"
    elif [ "$method" = "POST" ]; then
        curl -s -X POST -H "${headers[0]}" -H "${headers[1]}" -d "$data" "$url"
    elif [ "$method" = "PATCH" ]; then
        curl -s -X PATCH -H "${headers[0]}" -H "${headers[1]}" -d "$data" "$url"
    fi
}

# Función para obtener el ID de un módulo en Airtable
get_module_id() {
    local module_name=$1
    local airtable_name=$(get_airtable_module_name "$module_name")
    
    if [ -z "$airtable_name" ]; then
        log_error "Módulo '$module_name' no está mapeado"
        return 1
    fi
    
    # Usar una búsqueda más simple sin filterByFormula
    local response=$(airtable_request "GET" "${AIRTABLE_MODULES_TABLE}")
    echo "$response" | jq -r --arg name "$airtable_name" '.records[] | select(.fields.Name == $name) | .id // empty'
}

# Función para obtener los proyectos que usan un módulo
get_projects_using_module() {
    local module_name=$1
    local module_id=$(get_module_id "$module_name")
    
    if [ -z "$module_id" ]; then
        log_error "No se pudo obtener el ID del módulo '$module_name'"
        return 1
    fi
    
    # Obtener todos los proyectos y filtrar por ID del módulo
    local response=$(airtable_request "GET" "${AIRTABLE_PROJECTS_TABLE}")
    echo "$response" | jq -r --arg module_id "$module_id" '.records[] | select(.fields.MODULOS // [] | contains([$module_id])) | {id: .id, name: .fields["PROJECT Name"], branch: .fields["Rama principal"]}'
}

# Función para actualizar un módulo en Airtable
update_module_in_airtable() {
    local module_id=$1
    local version=$2
    local commit_hash=$3
    local author=$4
    local files_list=$5
    
    local data=$(cat << EOF
{
    "fields": {
        "Versión actual": "$version",
        "Último commit hash": "$commit_hash",
        "Autor último cambio": "$author"
    }
}
EOF
)
    
    airtable_request "PATCH" "${AIRTABLE_MODULES_TABLE}/${module_id}" "$data"
}

# Función para crear una propagación en Airtable
create_propagation_in_airtable() {
    local module_id=$1
    local project_id=$2
    local version=$3
    local commit_hash=$4
    local author=$5
    local files_list=$6
    local description=$7
    
    local data=$(cat << EOF
{
    "fields": {
        "Módulo": ["$module_id"],
        "Proyecto": ["$project_id"],
        "Versión propagada": "$version",
        "Commit hash": "$commit_hash",
        "Fecha de propagación": "$(date +%Y-%m-%d)",
        "Estado": "pendiente",
        "Archivos propagados": "$files_list",
        "Autor": "$author",
        "Notas": "Propagación automática desde script",
        "Duración de propagación": 0,
        "Descripción del cambio": "$description"
    }
}
EOF
)
    
    airtable_request "POST" "${AIRTABLE_PROPAGATIONS_TABLE}" "$data"
}

# Función para detectar archivos del módulo
detect_module_files() {
    local module_name=$1
    
    # Leer archivos del módulo desde modules.json
    local files=$(jq -r ".$module_name[]?" modules.json 2>/dev/null)
    
    if [ -z "$files" ]; then
        log_warning "No se encontraron archivos para el módulo '$module_name' en modules.json"
        return 1
    fi
    
    echo "$files" | tr '\n' ', ' | sed 's/, $//'
}

# Función para obtener información del commit actual
get_commit_info() {
    local commit_hash=$(git rev-parse --short HEAD 2>/dev/null || echo "local")
    local author=$(git config user.name 2>/dev/null || whoami)
    echo "$commit_hash|$author"
}

# Función para generar versión del módulo
generate_module_version() {
    local module_name=$1
    local current_date=$(date +%Y-%m-%d)
    
    # Intentar obtener la versión actual desde Airtable
    local module_id=$(get_module_id "$module_name")
    if [ -n "$module_id" ]; then
        local response=$(airtable_request "GET" "${AIRTABLE_MODULES_TABLE}/${module_id}")
        local current_version=$(echo "$response" | jq -r '.fields["Versión actual"] // empty')
        
        if [ -n "$current_version" ] && [ "$current_version" != "null" ]; then
            # Incrementar versión
            local version_prefix=$(echo "$current_version" | cut -d'-' -f1-3)
            local version_number=$(echo "$current_version" | cut -d'-' -f4)
            local new_version_number=$((version_number + 1))
            echo "${version_prefix}-$(printf "%03d" $new_version_number)"
            return
        fi
    fi
    
    # Versión inicial
    echo "${current_date}-001"
}

# Función para propagar automáticamente el módulo
auto_propagate_module() {
    local module_id=$1
    local version=$2
    local commit_hash=$3
    local author=$4
    local files_list=$5
    local description=$6
    
    log_step "Creando propagaciones automáticas..."
    
    # Obtener proyectos que usan este módulo
    local projects=$(get_projects_using_module "$MODULE_NAME")
    
    if [ -z "$projects" ]; then
        log_warning "No se encontraron proyectos que usen el módulo '$MODULE_NAME'"
        return
    fi
    
    local propagation_count=0
    
    # Crear propagación para cada proyecto
    echo "$projects" | jq -c '.' | while read -r project; do
        local project_id=$(echo "$project" | jq -r '.id')
        local project_name=$(echo "$project" | jq -r '.name')
        local branch=$(echo "$project" | jq -r '.branch')
        
        log_info "Creando propagación para: $project_name (rama: $branch)"
        
        local response=$(create_propagation_in_airtable \
            "$module_id" \
            "$project_id" \
            "$version" \
            "$commit_hash" \
            "$author" \
            "$files_list" \
            "$description")
        
        if echo "$response" | jq -e '.id' > /dev/null 2>&1; then
            log_success "Propagación creada para $project_name"
            propagation_count=$((propagation_count + 1))
        else
            log_error "Error al crear propagación para $project_name"
        fi
    done
    
    log_success "Se crearon $propagation_count propagaciones pendientes"
}

# Función para mostrar proyectos que necesitan propagación
show_projects_needing_propagation() {
    local module_name=$1
    local module_id=$(get_module_id "$module_name")
    
    if [ -z "$module_id" ]; then
        log_error "No se pudo obtener el ID del módulo '$module_name'"
        return 1
    fi
    
    # Obtener todos los proyectos que usan este módulo
    local response=$(airtable_request "GET" "${AIRTABLE_PROJECTS_TABLE}")
    local projects=$(echo "$response" | jq -r --arg module_id "$module_id" '.records[] | select(.fields.MODULOS // [] | contains([$module_id])) | {id: .id, name: .fields["PROJECT Name"], branch: .fields["Rama principal"]}')
    
    if [ -z "$projects" ]; then
        log_warning "No se encontraron proyectos que usen el módulo '$module_name'"
        return
    fi
    
    local project_count=0
    
    log_step "Proyectos que necesitan propagación del módulo '$module_name':"
    echo ""
    echo "$projects" | jq -c '.' | while read -r project; do
        local project_id=$(echo "$project" | jq -r '.id')
        local project_name=$(echo "$project" | jq -r '.name')
        local branch=$(echo "$project" | jq -r '.branch')
        
        echo "  📁 $project_name (rama: $branch)"
        project_count=$((project_count + 1))
    done
    
    echo ""
    log_info "Total de proyectos que necesitan propagación: $project_count"
    echo ""
    echo "💡 Para propagar manualmente:"
    echo "   ./propagate_module_from_json.sh $module_name"
    echo ""
    echo "📊 Ver en Airtable: https://airtable.com/${AIRTABLE_BASE_ID}/${AIRTABLE_PROJECTS_TABLE}"
}

# Función para verificar configuración
check_config() {
    if [ -z "$AIRTABLE_API_KEY" ]; then
        log_error "AIRTABLE_API_KEY no está configurado"
        echo "Edita el archivo scripts/track-module.sh y configura tu API Key"
        exit 1
    fi
    
    if [ -z "$AIRTABLE_BASE_ID" ]; then
        log_error "AIRTABLE_BASE_ID no está configurado"
        echo "Edita el archivo scripts/track-module.sh y configura tu Base ID"
        exit 1
    fi
}

# Función para crear registros pendientes en PROPAGACIONES
create_pending_propagations() {
    local module_name=$1
    local version=$2
    local commit_hash=$3
    local author=$4
    local files_list=$5
    local description=$6

    local module_id=$(get_module_id "$module_name")
    if [ -z "$module_id" ]; then
        log_error "No se pudo obtener el ID del módulo '$module_name' para crear propagaciones pendientes."
        return 1
    fi

    local response=$(airtable_request "GET" "${AIRTABLE_PROJECTS_TABLE}")
    local projects=$(echo "$response" | jq -r --arg module_id "$module_id" '.records[] | select(.fields.MODULOS // [] | contains([$module_id])) | {id: .id, name: .fields["PROJECT Name"], branch: .fields["Rama principal"]}')

    if [ -z "$projects" ]; then
        log_warning "No se encontraron proyectos que usen el módulo '$module_name' para crear propagaciones pendientes."
        return
    fi

    local count=0
    echo "$projects" | jq -c '.' | while read -r project; do
        local project_id=$(echo "$project" | jq -r '.id')
        local project_name=$(echo "$project" | jq -r '.name')
        local branch=$(echo "$project" | jq -r '.branch')

        # Crear registro en PROPAGACIONES con estado Pendiente
        local data=$(cat << EOF
{
    "fields": {
        "Módulo": ["$module_id"],
        "Proyecto": ["$project_id"],
        "Versión propagada": "$version",
        "Commit hash": "$commit_hash",
        "Fecha de propagación": "$(date +%Y-%m-%d)",
        "Estado": "Pendiente",
        "Archivos propagados": "$files_list",
        "Autor": "$author",
        "Notas": "Tracking automático: pendiente de propagación",
        "Duración de propagación": 0,
        "Descripción del cambio": "$description"
    }
}
EOF
)
        local resp=$(airtable_request "POST" "${AIRTABLE_PROPAGATIONS_TABLE}" "$data")
        if echo "$resp" | jq -e '.id' > /dev/null 2>&1; then
            log_success "Registro pendiente creado para $project_name ($branch)"
            count=$((count + 1))
        else
            log_error "Error al crear registro pendiente para $project_name ($branch)"
            echo "Respuesta: $resp"
        fi
    done
    log_info "Total de registros pendientes creados: $count"
}


# Función principal
main() {
    if [ -z "$MODULE_NAME" ] || [ -z "$DESCRIPTION" ]; then
        echo "Uso: $0 <module_name> \"descripción del cambio\""
        echo ""
        echo "Este script trackea cambios en módulos y actualiza Airtable."
        echo "NO hace propagaciones automáticas - solo registra qué proyectos necesitan actualización."
        echo ""
        echo "Módulos disponibles:"
        echo "  - gallery → GALLERY IMAGE"
        echo "  - blog → BLOG"
        echo "  - services → SERVICES"
        echo "  - products → PRODUCTS"
        echo "  - projects → PROJECTS"
        echo "  - team → TEAM PROFILES"
        echo "  - references → REFERENCES"
        echo "  - cd-base → CD-BASE"
        echo ""
        echo "Ejemplo: $0 gallery \"Mejora del slider con filtros\""
        echo ""
        echo "Después de trackear, puedes propagar manualmente cuando estés listo:"
        echo "  ./propagate_module_from_json.sh gallery"
        exit 1
    fi
    
    # Verificar configuración
    check_config
    
    log_step "Iniciando tracking del módulo '$MODULE_NAME'"
    
    # Obtener información del commit
    local commit_info=$(get_commit_info)
    local commit_hash=$(echo "$commit_info" | cut -d'|' -f1)
    local author=$(echo "$commit_info" | cut -d'|' -f2)
    
    # Generar versión del módulo
    local version=$(generate_module_version "$MODULE_NAME")
    
    # Detectar archivos del módulo
    local files_list=$(detect_module_files "$MODULE_NAME")
    
    if [ -z "$files_list" ]; then
        log_error "No se pudieron detectar archivos para el módulo '$MODULE_NAME'"
        exit 1
    fi
    
    log_info "Versión: $version"
    log_info "Commit: $commit_hash"
    log_info "Autor: $author"
    log_info "Archivos: $files_list"
    
    # Obtener ID del módulo en Airtable
    local module_id=$(get_module_id "$MODULE_NAME")
    
    if [ -z "$module_id" ]; then
        log_error "No se encontró el módulo '$MODULE_NAME' en Airtable"
        log_info "Asegúrate de que el módulo esté registrado en la tabla MODULOS"
        exit 1
    fi
    
    log_info "ID del módulo en Airtable: $module_id"
    
    # Actualizar módulo en Airtable
    log_step "Actualizando módulo en Airtable..."
    local update_response=$(update_module_in_airtable "$module_id" "$version" "$commit_hash" "$author" "$files_list")
    
    if echo "$update_response" | jq -e '.id' > /dev/null 2>&1; then
        log_success "Módulo actualizado en Airtable"
    else
        log_error "Error al actualizar módulo en Airtable"
        echo "Respuesta: $update_response"
        exit 1
    fi
    
    # Crear registros pendientes en PROPAGACIONES
    create_pending_propagations "$MODULE_NAME" "$version" "$commit_hash" "$author" "$files_list" "$DESCRIPTION"

    # Mostrar proyectos que necesitan propagación
    show_projects_needing_propagation "$MODULE_NAME"
    
    log_success "¡Tracking completado para el módulo '$MODULE_NAME'!"
    echo ""
    echo "📊 Resumen:"
    echo "  Módulo: $MODULE_NAME → $(get_airtable_module_name "$MODULE_NAME")"
    echo "  Versión: $version"
    echo "  Commit: $commit_hash"
    echo "  Autor: $author"
    echo "  Descripción: $DESCRIPTION"
    echo ""
    echo "🔗 Ver en Airtable: https://airtable.com/${AIRTABLE_BASE_ID}/${AIRTABLE_MODULES_TABLE}"
    echo ""
    echo "💡 Para propagar manualmente cuando estés listo:"
    echo "   ./propagate_module_from_json.sh $MODULE_NAME"
    echo ""
    echo "📋 El módulo está marcado como desactualizado en todos los proyectos que lo usan."
    echo "   Puedes ver el estado en la tabla PROYECTOS de Airtable."
}

# Ejecutar función principal
main "$@"