//! Phase 169: JoinIR Condition Lowering Helper
//!
//! This module provides AST → JoinIR condition lowering for loop patterns.
//! Unlike BoolExprLowerer (which generates MIR), this generates JoinIR instructions.
//!
//! ## Design Philosophy
//!
//! **Separation of Concerns**:
//! - BoolExprLowerer: AST → MIR (for regular control flow)
//! - condition_to_joinir: AST → JoinIR (for loop lowerers)
//!
//! This dual approach maintains clean boundaries:
//! - Loop lowerers work in JoinIR space (pure functional transformation)
//! - Regular control flow uses MIR space (stateful builder)
//!
//! ## Usage Example
//!
//! ```rust
//! let mut value_counter = 0u32;
//! let mut alloc_value = || {
//!     let id = ValueId(value_counter);
//!     value_counter += 1;
//!     id
//! };
//!
//! // Lower condition: i < end
//! let (cond_value, cond_insts) = lower_condition_to_joinir(
//!     condition_ast,
//!     &mut alloc_value,
//!     builder,
//! )?;
//!
//! // cond_value: ValueId holding boolean result
//! // cond_insts: Vec<JoinInst::Compute> to evaluate condition
//! ```

use crate::ast::{ASTNode, BinaryOperator, LiteralValue, UnaryOperator};
use crate::mir::join_ir::{BinOpKind, CompareOp, ConstValue, JoinInst, MirLikeInst};
use crate::mir::ValueId;
use std::collections::HashMap;

/// Phase 171-fix: Environment for condition expression lowering
/// Maps variable names to JoinIR-local ValueIds
#[derive(Debug, Clone, Default)]
pub struct ConditionEnv {
    pub name_to_join: HashMap<String, ValueId>,
}

impl ConditionEnv {
    pub fn new() -> Self {
        Self { name_to_join: HashMap::new() }
    }

    pub fn insert(&mut self, name: String, join_id: ValueId) {
        self.name_to_join.insert(name, join_id);
    }

    pub fn get(&self, name: &str) -> Option<ValueId> {
        self.name_to_join.get(name).copied()
    }
}

/// Phase 171-fix: Binding between HOST and JoinIR ValueIds for condition variables
#[derive(Debug, Clone)]
pub struct ConditionBinding {
    pub name: String,
    pub host_value: ValueId,
    pub join_value: ValueId,
}

/// Lower an AST condition to JoinIR instructions
///
/// Phase 171-fix: Changed to use ConditionEnv instead of builder
///
/// # Arguments
///
/// * `cond_ast` - AST node representing the boolean condition
/// * `alloc_value` - ValueId allocator function
/// * `env` - ConditionEnv for variable resolution (JoinIR-local ValueIds)
///
/// # Returns
///
/// * `Ok((ValueId, Vec<JoinInst>))` - Condition result ValueId and evaluation instructions
/// * `Err(String)` - Lowering error message
///
/// # Supported Patterns
///
/// - Comparisons: `i < n`, `x == y`, `a != b`, `x <= y`, `x >= y`, `x > y`
/// - Logical: `a && b`, `a || b`, `!cond`
/// - Variables and literals
pub fn lower_condition_to_joinir<F>(
    cond_ast: &ASTNode,
    alloc_value: &mut F,
    env: &ConditionEnv,
) -> Result<(ValueId, Vec<JoinInst>), String>
where
    F: FnMut() -> ValueId,
{
    let mut instructions = Vec::new();
    let result_value = lower_condition_recursive(cond_ast, alloc_value, env, &mut instructions)?;
    Ok((result_value, instructions))
}

/// Recursive helper for condition lowering
///
/// Phase 171-fix: Changed to use ConditionEnv instead of builder
fn lower_condition_recursive<F>(
    cond_ast: &ASTNode,
    alloc_value: &mut F,
    env: &ConditionEnv,
    instructions: &mut Vec<JoinInst>,
) -> Result<ValueId, String>
where
    F: FnMut() -> ValueId,
{
    match cond_ast {
        // Comparison operations: <, ==, !=, <=, >=, >
        ASTNode::BinaryOp {
            operator,
            left,
            right,
            ..
        } => match operator {
            BinaryOperator::Less
            | BinaryOperator::Equal
            | BinaryOperator::NotEqual
            | BinaryOperator::LessEqual
            | BinaryOperator::GreaterEqual
            | BinaryOperator::Greater => {
                // Lower left and right sides
                let lhs = lower_value_expression(left, alloc_value, env, instructions)?;
                let rhs = lower_value_expression(right, alloc_value, env, instructions)?;
                let dst = alloc_value();

                let cmp_op = match operator {
                    BinaryOperator::Less => CompareOp::Lt,
                    BinaryOperator::Equal => CompareOp::Eq,
                    BinaryOperator::NotEqual => CompareOp::Ne,
                    BinaryOperator::LessEqual => CompareOp::Le,
                    BinaryOperator::GreaterEqual => CompareOp::Ge,
                    BinaryOperator::Greater => CompareOp::Gt,
                    _ => unreachable!(),
                };

                // Emit Compare instruction
                instructions.push(JoinInst::Compute(MirLikeInst::Compare {
                    dst,
                    op: cmp_op,
                    lhs,
                    rhs,
                }));

                Ok(dst)
            }
            BinaryOperator::And => {
                // Logical AND: evaluate both sides and combine
                let lhs = lower_condition_recursive(left, alloc_value, env, instructions)?;
                let rhs = lower_condition_recursive(right, alloc_value, env, instructions)?;
                let dst = alloc_value();

                // Emit BinOp And instruction
                instructions.push(JoinInst::Compute(MirLikeInst::BinOp {
                    dst,
                    op: BinOpKind::And,
                    lhs,
                    rhs,
                }));

                Ok(dst)
            }
            BinaryOperator::Or => {
                // Logical OR: evaluate both sides and combine
                let lhs = lower_condition_recursive(left, alloc_value, env, instructions)?;
                let rhs = lower_condition_recursive(right, alloc_value, env, instructions)?;
                let dst = alloc_value();

                // Emit BinOp Or instruction
                instructions.push(JoinInst::Compute(MirLikeInst::BinOp {
                    dst,
                    op: BinOpKind::Or,
                    lhs,
                    rhs,
                }));

                Ok(dst)
            }
            _ => {
                // Other operators (arithmetic, etc.)
                Err(format!(
                    "Unsupported binary operator in condition: {:?}",
                    operator
                ))
            }
        },

        // Unary NOT operator
        ASTNode::UnaryOp {
            operator: UnaryOperator::Not,
            operand,
            ..
        } => {
            let operand_val = lower_condition_recursive(operand, alloc_value, env, instructions)?;
            let dst = alloc_value();

            // Emit UnaryOp Not instruction
            instructions.push(JoinInst::Compute(MirLikeInst::UnaryOp {
                dst,
                op: crate::mir::join_ir::UnaryOp::Not,
                operand: operand_val,
            }));

            Ok(dst)
        }

        // Variables - resolve from ConditionEnv (Phase 171-fix)
        ASTNode::Variable { name, .. } => {
            // Look up variable in ConditionEnv (JoinIR-local ValueIds)
            env.get(name)
                .ok_or_else(|| format!("Variable '{}' not bound in ConditionEnv", name))
        }

        // Literals - emit as constants
        ASTNode::Literal { value, .. } => {
            let dst = alloc_value();
            let const_value = match value {
                LiteralValue::Integer(n) => ConstValue::Integer(*n),
                LiteralValue::String(s) => ConstValue::String(s.clone()),
                LiteralValue::Bool(b) => ConstValue::Bool(*b),
                LiteralValue::Float(_) => {
                    // Float literals not supported in JoinIR ConstValue yet
                    return Err("Float literals not supported in JoinIR conditions yet".to_string());
                }
                _ => {
                    return Err(format!("Unsupported literal type in condition: {:?}", value));
                }
            };

            instructions.push(JoinInst::Compute(MirLikeInst::Const {
                dst,
                value: const_value,
            }));

            Ok(dst)
        }

        _ => Err(format!("Unsupported AST node in condition: {:?}", cond_ast)),
    }
}

/// Lower a value expression (for comparison operands, etc.)
///
/// Phase 171-fix: Changed to use ConditionEnv instead of builder
///
/// This handles the common case where we need to evaluate a simple value
/// (variable or literal) as part of a comparison.
fn lower_value_expression<F>(
    expr: &ASTNode,
    alloc_value: &mut F,
    env: &ConditionEnv,
    instructions: &mut Vec<JoinInst>,
) -> Result<ValueId, String>
where
    F: FnMut() -> ValueId,
{
    match expr {
        // Variables - look up in ConditionEnv (Phase 171-fix)
        ASTNode::Variable { name, .. } => env
            .get(name)
            .ok_or_else(|| format!("Variable '{}' not bound in ConditionEnv", name)),

        // Literals - emit as constants
        ASTNode::Literal { value, .. } => {
            let dst = alloc_value();
            let const_value = match value {
                LiteralValue::Integer(n) => ConstValue::Integer(*n),
                LiteralValue::String(s) => ConstValue::String(s.clone()),
                LiteralValue::Bool(b) => ConstValue::Bool(*b),
                LiteralValue::Float(_) => {
                    // Float literals not supported in JoinIR ConstValue yet
                    return Err("Float literals not supported in JoinIR value expressions yet".to_string());
                }
                _ => {
                    return Err(format!("Unsupported literal type: {:?}", value));
                }
            };

            instructions.push(JoinInst::Compute(MirLikeInst::Const {
                dst,
                value: const_value,
            }));

            Ok(dst)
        }

        // Binary operations (for arithmetic in conditions like i + 1 < n)
        ASTNode::BinaryOp {
            operator,
            left,
            right,
            ..
        } => {
            let lhs = lower_value_expression(left, alloc_value, env, instructions)?;
            let rhs = lower_value_expression(right, alloc_value, env, instructions)?;
            let dst = alloc_value();

            let bin_op = match operator {
                BinaryOperator::Add => BinOpKind::Add,
                BinaryOperator::Subtract => BinOpKind::Sub,
                BinaryOperator::Multiply => BinOpKind::Mul,
                BinaryOperator::Divide => BinOpKind::Div,
                BinaryOperator::Modulo => BinOpKind::Mod,
                _ => {
                    return Err(format!("Unsupported binary operator in expression: {:?}", operator));
                }
            };

            instructions.push(JoinInst::Compute(MirLikeInst::BinOp {
                dst,
                op: bin_op,
                lhs,
                rhs,
            }));

            Ok(dst)
        }

        _ => Err(format!("Unsupported expression in value context: {:?}", expr)),
    }
}

/// Extract all variable names used in a condition AST (Phase 171)
///
/// This helper recursively traverses the condition AST and collects all
/// unique variable names. Used to determine which variables need to be
/// available in JoinIR scope.
///
/// # Arguments
///
/// * `cond_ast` - AST node representing the condition
/// * `exclude_vars` - Variable names to exclude (e.g., loop parameters already registered)
///
/// # Returns
///
/// Sorted vector of unique variable names found in the condition
///
/// # Example
///
/// ```ignore
/// // For condition: start < end && i < len
/// let vars = extract_condition_variables(
///     condition_ast,
///     &["i".to_string()],  // Exclude loop variable 'i'
/// );
/// // Result: ["end", "len", "start"] (sorted, 'i' excluded)
/// ```
pub fn extract_condition_variables(
    cond_ast: &ASTNode,
    exclude_vars: &[String],
) -> Vec<String> {
    use std::collections::BTreeSet;

    let mut all_vars = BTreeSet::new();
    collect_variables_recursive(cond_ast, &mut all_vars);

    // Filter out excluded variables and return sorted list
    all_vars.into_iter()
        .filter(|name| !exclude_vars.contains(name))
        .collect()
}

/// Recursive helper to collect variable names
fn collect_variables_recursive(ast: &ASTNode, vars: &mut std::collections::BTreeSet<String>) {
    match ast {
        ASTNode::Variable { name, .. } => {
            vars.insert(name.clone());
        }
        ASTNode::BinaryOp { left, right, .. } => {
            collect_variables_recursive(left, vars);
            collect_variables_recursive(right, vars);
        }
        ASTNode::UnaryOp { operand, .. } => {
            collect_variables_recursive(operand, vars);
        }
        ASTNode::Literal { .. } => {
            // Literals have no variables
        }
        _ => {
            // Other AST nodes not expected in conditions
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ast::{ASTNode, BinaryOperator, LiteralValue, Span};

    /// Phase 171-fix: Helper to create a test ConditionEnv with variables
    fn create_test_env() -> ConditionEnv {
        let mut env = ConditionEnv::new();
        // Register test variables (using JoinIR-local ValueIds)
        env.insert("i".to_string(), ValueId(0));
        env.insert("end".to_string(), ValueId(1));
        env
    }

    #[test]
    fn test_simple_comparison() {
        let env = create_test_env();
        let mut value_counter = 2u32; // Start after i=0, end=1
        let mut alloc_value = || {
            let id = ValueId(value_counter);
            value_counter += 1;
            id
        };

        // AST: i < end
        let ast = ASTNode::BinaryOp {
            operator: BinaryOperator::Less,
            left: Box::new(ASTNode::Variable {
                name: "i".to_string(),
                span: Span::unknown(),
            }),
            right: Box::new(ASTNode::Variable {
                name: "end".to_string(),
                span: Span::unknown(),
            }),
            span: Span::unknown(),
        };

        let result = lower_condition_to_joinir(&ast, &mut alloc_value, &env);
        assert!(result.is_ok(), "Simple comparison should succeed");

        let (_cond_value, instructions) = result.unwrap();
        assert_eq!(instructions.len(), 1, "Should generate 1 Compare instruction");
    }

    #[test]
    fn test_comparison_with_literal() {
        let env = create_test_env();
        let mut value_counter = 2u32;
        let mut alloc_value = || {
            let id = ValueId(value_counter);
            value_counter += 1;
            id
        };

        // AST: i < 10
        let ast = ASTNode::BinaryOp {
            operator: BinaryOperator::Less,
            left: Box::new(ASTNode::Variable {
                name: "i".to_string(),
                span: Span::unknown(),
            }),
            right: Box::new(ASTNode::Literal {
                value: LiteralValue::Integer(10),
                span: Span::unknown(),
            }),
            span: Span::unknown(),
        };

        let result = lower_condition_to_joinir(&ast, &mut alloc_value, &env);
        assert!(result.is_ok(), "Comparison with literal should succeed");

        let (_cond_value, instructions) = result.unwrap();
        // Should have: Const(10), Compare
        assert_eq!(instructions.len(), 2, "Should generate Const + Compare");
    }

    #[test]
    fn test_logical_or() {
        let mut env = ConditionEnv::new();
        env.insert("a".to_string(), ValueId(2));
        env.insert("b".to_string(), ValueId(3));

        let mut value_counter = 4u32;
        let mut alloc_value = || {
            let id = ValueId(value_counter);
            value_counter += 1;
            id
        };

        // AST: a < 5 || b < 5
        let ast = ASTNode::BinaryOp {
            operator: BinaryOperator::Or,
            left: Box::new(ASTNode::BinaryOp {
                operator: BinaryOperator::Less,
                left: Box::new(ASTNode::Variable {
                    name: "a".to_string(),
                    span: Span::unknown(),
                }),
                right: Box::new(ASTNode::Literal {
                    value: LiteralValue::Integer(5),
                    span: Span::unknown(),
                }),
                span: Span::unknown(),
            }),
            right: Box::new(ASTNode::BinaryOp {
                operator: BinaryOperator::Less,
                left: Box::new(ASTNode::Variable {
                    name: "b".to_string(),
                    span: Span::unknown(),
                }),
                right: Box::new(ASTNode::Literal {
                    value: LiteralValue::Integer(5),
                    span: Span::unknown(),
                }),
                span: Span::unknown(),
            }),
            span: Span::unknown(),
        };

        let result = lower_condition_to_joinir(&ast, &mut alloc_value, &env);
        assert!(result.is_ok(), "OR expression should succeed");

        let (_cond_value, instructions) = result.unwrap();
        // Should have: Const(5), Compare(a<5), Const(5), Compare(b<5), BinOp(Or)
        assert_eq!(instructions.len(), 5, "Should generate proper OR chain");
    }

    #[test]
    fn test_extract_condition_variables_simple() {
        // AST: start < end
        let ast = ASTNode::BinaryOp {
            operator: BinaryOperator::Less,
            left: Box::new(ASTNode::Variable {
                name: "start".to_string(),
                span: Span::unknown(),
            }),
            right: Box::new(ASTNode::Variable {
                name: "end".to_string(),
                span: Span::unknown(),
            }),
            span: Span::unknown(),
        };

        let vars = extract_condition_variables(&ast, &[]);
        assert_eq!(vars, vec!["end", "start"]);  // Sorted order
    }

    #[test]
    fn test_extract_condition_variables_with_exclude() {
        // AST: i < end
        let ast = ASTNode::BinaryOp {
            operator: BinaryOperator::Less,
            left: Box::new(ASTNode::Variable {
                name: "i".to_string(),
                span: Span::unknown(),
            }),
            right: Box::new(ASTNode::Variable {
                name: "end".to_string(),
                span: Span::unknown(),
            }),
            span: Span::unknown(),
        };

        let vars = extract_condition_variables(&ast, &["i".to_string()]);
        assert_eq!(vars, vec!["end"]);  // 'i' excluded
    }

    #[test]
    fn test_extract_condition_variables_complex() {
        // AST: start < end && i < len
        let ast = ASTNode::BinaryOp {
            operator: BinaryOperator::And,
            left: Box::new(ASTNode::BinaryOp {
                operator: BinaryOperator::Less,
                left: Box::new(ASTNode::Variable {
                    name: "start".to_string(),
                    span: Span::unknown(),
                }),
                right: Box::new(ASTNode::Variable {
                    name: "end".to_string(),
                    span: Span::unknown(),
                }),
                span: Span::unknown(),
            }),
            right: Box::new(ASTNode::BinaryOp {
                operator: BinaryOperator::Less,
                left: Box::new(ASTNode::Variable {
                    name: "i".to_string(),
                    span: Span::unknown(),
                }),
                right: Box::new(ASTNode::Variable {
                    name: "len".to_string(),
                    span: Span::unknown(),
                }),
                span: Span::unknown(),
            }),
            span: Span::unknown(),
        };

        let vars = extract_condition_variables(&ast, &["i".to_string()]);
        assert_eq!(vars, vec!["end", "len", "start"]);  // Sorted, 'i' excluded
    }
}