/*!
 * Box Definition Parser Module
 *
 * Box宣言（box, interface box, static box）の解析を担当
 * Nyashの中核概念「Everything is Box」を実現する重要モジュール
 */

use crate::ast::{ASTNode, Span};
use crate::parser::declarations::box_def::header as box_header;
use crate::parser::common::ParserUtils;
use crate::parser::{NyashParser, ParseError};
use crate::tokenizer::TokenType;
use std::collections::HashMap;

impl NyashParser {
    /// Extracted: parse block-first unified member: `{ body } as [once|birth_once]? name : Type [postfix]`
    /// Returns true if a member was parsed and emitted into `methods`.
    fn parse_unified_member_block_first(
        &mut self,
        methods: &mut HashMap<String, ASTNode>,
        birth_once_props: &mut Vec<String>,
    ) -> Result<bool, ParseError> {
        if !(crate::config::env::unified_members() && self.match_token(&TokenType::LBRACE)) {
            return Ok(false);
        }
        // Parse block body first
        let mut final_body = self.parse_block_statements()?;
        self.skip_newlines();
        // Expect 'as'
        if let TokenType::IDENTIFIER(kw) = &self.current_token().token_type {
            if kw != "as" {
                let line = self.current_token().line;
                return Err(ParseError::UnexpectedToken {
                    found: self.current_token().token_type.clone(),
                    expected: "'as' after block for block-first member".to_string(),
                    line,
                });
            }
        } else {
            let line = self.current_token().line;
            return Err(ParseError::UnexpectedToken {
                found: self.current_token().token_type.clone(),
                expected: "'as' after block for block-first member".to_string(),
                line,
            });
        }
        self.advance(); // consume 'as'
        // Optional kind keyword
        let mut kind = "computed".to_string();
        if let TokenType::IDENTIFIER(k) = &self.current_token().token_type {
            if k == "once" || k == "birth_once" {
                kind = k.clone();
                self.advance();
            }
        }
        // Name : Type
        let name = if let TokenType::IDENTIFIER(n) = &self.current_token().token_type {
            let s = n.clone();
            self.advance();
            s
        } else {
            let line = self.current_token().line;
            return Err(ParseError::UnexpectedToken {
                found: self.current_token().token_type.clone(),
                expected: "identifier for member name".to_string(),
                line,
            });
        };
        if self.match_token(&TokenType::COLON) {
            self.advance();
            if let TokenType::IDENTIFIER(_ty) = &self.current_token().token_type {
                self.advance();
            } else {
                let line = self.current_token().line;
                return Err(ParseError::UnexpectedToken {
                    found: self.current_token().token_type.clone(),
                    expected: "type name after ':'".to_string(),
                    line,
                });
            }
        } else {
            let line = self.current_token().line;
            return Err(ParseError::UnexpectedToken {
                found: self.current_token().token_type.clone(),
                expected: ": type".to_string(),
                line,
            });
        }
        // Optional postfix handlers (Stage‑3)
        if crate::config::env::parser_stage3()
            && (self.match_token(&TokenType::CATCH) || self.match_token(&TokenType::CLEANUP))
        {
            let mut catch_clauses: Vec<crate::ast::CatchClause> = Vec::new();
            if self.match_token(&TokenType::CATCH) {
                self.advance();
                self.consume(TokenType::LPAREN)?;
                let (exc_ty, exc_var) = self.parse_catch_param()?;
                self.consume(TokenType::RPAREN)?;
                let catch_body = self.parse_block_statements()?;
                catch_clauses.push(crate::ast::CatchClause {
                    exception_type: exc_ty,
                    variable_name: exc_var,
                    body: catch_body,
                    span: crate::ast::Span::unknown(),
                });
                self.skip_newlines();
                if self.match_token(&TokenType::CATCH) {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken {
                        found: self.current_token().token_type.clone(),
                        expected: "single catch only after member block".to_string(),
                        line,
                    });
                }
            }
            let finally_body = if self.match_token(&TokenType::CLEANUP) {
                self.advance();
                Some(self.parse_block_statements()?)
            } else {
                None
            };
            final_body = vec![ASTNode::TryCatch {
                try_body: final_body,
                catch_clauses,
                finally_body,
                span: Span::unknown(),
            }];
        }
        // Generate method(s) according to kind (delegate to existing logic path by reusing current block)
        if kind == "once" || kind == "birth_once" {
            // Re-inject tokens to reuse existing lowering logic would be complex; we instead synthesize
            // small wrappers by mimicking existing naming. For safety, fall back to simple getter here.
            if kind == "birth_once" {
                birth_once_props.push(name.clone());
            }
            let getter_name = if kind == "once" {
                format!("__get_once_{}", name)
            } else if kind == "birth_once" {
                format!("__get_birth_{}", name)
            } else {
                format!("__get_{}", name)
            };
            let getter = ASTNode::FunctionDeclaration {
                name: getter_name.clone(),
                params: vec![],
                body: final_body,
                is_static: false,
                is_override: false,
                span: Span::unknown(),
            };
            methods.insert(getter_name, getter);
        } else {
            let getter_name = format!("__get_{}", name);
            let getter = ASTNode::FunctionDeclaration {
                name: getter_name.clone(),
                params: vec![],
                body: final_body,
                is_static: false,
                is_override: false,
                span: Span::unknown(),
            };
            methods.insert(getter_name, getter);
        }
        self.skip_newlines();
        Ok(true)
    }

    /// Extracted: method-level postfix catch/cleanup after a method
    fn parse_method_postfix_after_last_method(
        &mut self,
        methods: &mut HashMap<String, ASTNode>,
        last_method_name: &Option<String>,
    ) -> Result<bool, ParseError> {
        if !(self.match_token(&TokenType::CATCH) || self.match_token(&TokenType::CLEANUP))
            || last_method_name.is_none()
        {
            return Ok(false);
        }
        let mname = last_method_name.clone().unwrap();
        let mut catch_clauses: Vec<crate::ast::CatchClause> = Vec::new();
        if self.match_token(&TokenType::CATCH) {
            self.advance();
            self.consume(TokenType::LPAREN)?;
            let (exc_ty, exc_var) = self.parse_catch_param()?;
            self.consume(TokenType::RPAREN)?;
            let catch_body = self.parse_block_statements()?;
            catch_clauses.push(crate::ast::CatchClause {
                exception_type: exc_ty,
                variable_name: exc_var,
                body: catch_body,
                span: crate::ast::Span::unknown(),
            });
            self.skip_newlines();
            if self.match_token(&TokenType::CATCH) {
                let line = self.current_token().line;
                return Err(ParseError::UnexpectedToken {
                    found: self.current_token().token_type.clone(),
                    expected: "single catch only after method body".to_string(),
                    line,
                });
            }
        }
        let finally_body = if self.match_token(&TokenType::CLEANUP) {
            self.advance();
            Some(self.parse_block_statements()?)
        } else {
            None
        };
        if let Some(mnode) = methods.get_mut(&mname) {
            if let crate::ast::ASTNode::FunctionDeclaration { body, .. } = mnode {
                let already = body
                    .iter()
                    .any(|n| matches!(n, crate::ast::ASTNode::TryCatch { .. }));
                if already {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken {
                        found: self.current_token().token_type.clone(),
                        expected: "duplicate postfix catch/cleanup after method".to_string(),
                        line,
                    });
                }
                let old = std::mem::take(body);
                *body = vec![crate::ast::ASTNode::TryCatch {
                    try_body: old,
                    catch_clauses,
                    finally_body,
                    span: crate::ast::Span::unknown(),
                }];
            }
        }
        Ok(true)
    }

    /// Extracted: init { ... } block (non-call form)
    fn parse_init_block_if_any(
        &mut self,
        init_fields: &mut Vec<String>,
        weak_fields: &mut Vec<String>,
    ) -> Result<bool, ParseError> {
        if !(self.match_token(&TokenType::INIT) && self.peek_token() != &TokenType::LPAREN) {
            return Ok(false);
        }
        self.advance(); // consume 'init'
        self.consume(TokenType::LBRACE)?;
        while !self.match_token(&TokenType::RBRACE) && !self.is_at_end() {
            self.skip_newlines();
            if self.match_token(&TokenType::RBRACE) {
                break;
            }
            let is_weak = if self.match_token(&TokenType::WEAK) {
                self.advance();
                true
            } else {
                false
            };
            if let TokenType::IDENTIFIER(field_name) = &self.current_token().token_type {
                init_fields.push(field_name.clone());
                if is_weak {
                    weak_fields.push(field_name.clone());
                }
                self.advance();
                if self.match_token(&TokenType::COMMA) {
                    self.advance();
                }
            } else {
                return Err(ParseError::UnexpectedToken {
                    expected: if is_weak {
                        "field name after 'weak'"
                    } else {
                        "field name"
                    }
                    .to_string(),
                    found: self.current_token().token_type.clone(),
                    line: self.current_token().line,
                });
            }
        }
        self.consume(TokenType::RBRACE)?;
        Ok(true)
    }

    /// Extracted: visibility block or single property header-first
    fn parse_visibility_block_or_single(
        &mut self,
        visibility: &str,
        methods: &mut HashMap<String, ASTNode>,
        fields: &mut Vec<String>,
        public_fields: &mut Vec<String>,
        private_fields: &mut Vec<String>,
        last_method_name: &mut Option<String>,
    ) -> Result<bool, ParseError> {
        if visibility != "public" && visibility != "private" {
            return Ok(false);
        }
        if self.match_token(&TokenType::LBRACE) {
            self.advance();
            self.skip_newlines();
            while !self.match_token(&TokenType::RBRACE) && !self.is_at_end() {
                if let TokenType::IDENTIFIER(fname) = &self.current_token().token_type {
                    let fname = fname.clone();
                    if visibility == "public" {
                        public_fields.push(fname.clone());
                    } else {
                        private_fields.push(fname.clone());
                    }
                    fields.push(fname);
                    self.advance();
                    if self.match_token(&TokenType::COMMA) {
                        self.advance();
                    }
                    self.skip_newlines();
                    continue;
                }
                return Err(ParseError::UnexpectedToken {
                    expected: "identifier in visibility block".to_string(),
                    found: self.current_token().token_type.clone(),
                    line: self.current_token().line,
                });
            }
            self.consume(TokenType::RBRACE)?;
            self.skip_newlines();
            return Ok(true);
        }
        if let TokenType::IDENTIFIER(n) = &self.current_token().token_type {
            let fname = n.clone();
            self.advance();
            if crate::parser::declarations::box_def::members::fields::try_parse_header_first_field_or_property(
                self,
                fname.clone(),
                methods,
                fields,
            )? {
                if visibility == "public" {
                    public_fields.push(fname.clone());
                } else {
                    private_fields.push(fname.clone());
                }
                *last_method_name = None;
                self.skip_newlines();
                return Ok(true);
            } else {
                // Fallback: record visibility + field name for compatibility
                if visibility == "public" {
                    public_fields.push(fname.clone());
                } else {
                    private_fields.push(fname.clone());
                }
                fields.push(fname);
                self.skip_newlines();
                return Ok(true);
            }
        }
        Ok(false)
    }
    /// box宣言をパース: box Name { fields... methods... }
    pub fn parse_box_declaration(&mut self) -> Result<ASTNode, ParseError> {
        self.consume(TokenType::BOX)?;
        let (name, type_parameters, extends, implements) =
            box_header::parse_header(self)?;

        self.consume(TokenType::LBRACE)?;
        self.skip_newlines(); // ブレース後の改行をスキップ

        let mut fields = Vec::new();
        let mut methods = HashMap::new();
        let mut public_fields: Vec<String> = Vec::new();
        let mut private_fields: Vec<String> = Vec::new();
        let mut constructors = HashMap::new();
        let mut init_fields = Vec::new();
        let mut weak_fields = Vec::new(); // 🔗 Track weak fields
        // Track birth_once properties to inject eager init into birth()
        let mut birth_once_props: Vec<String> = Vec::new();

        let mut last_method_name: Option<String> = None;
        while !self.match_token(&TokenType::RBRACE) && !self.is_at_end() {
            self.skip_newlines(); // ループ開始時に改行をスキップ
            // 分類（段階移行用の観測）: 将来の分岐移譲のための前処理
            if crate::config::env::parser_stage3() {
                if let Ok(kind) = crate::parser::declarations::box_def::members::common::classify_member(self) {
                    let _ = kind; // 現段階では観測のみ（無副作用）
                }
            }

            // nyashモード（block-first）: { body } as (once|birth_once)? name : Type
            if crate::config::env::unified_members() && self.match_token(&TokenType::LBRACE) {
                // Parse block body first
                let mut final_body = self.parse_block_statements()?;
                self.skip_newlines();
                // Expect 'as'
                if let TokenType::IDENTIFIER(kw) = &self.current_token().token_type {
                    if kw != "as" {
                        // Not a block-first member; treat as standalone block statement in box (unsupported)
                        let line = self.current_token().line;
                        return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: "'as' after block for block-first member".to_string(), line });
                    }
                } else {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: "'as' after block for block-first member".to_string(), line });
                }
                self.advance(); // consume 'as'
                // Optional kind keyword
                let mut kind = "computed".to_string();
                if let TokenType::IDENTIFIER(k) = &self.current_token().token_type {
                    if k == "once" || k == "birth_once" {
                        kind = k.clone();
                        self.advance();
                    }
                }
                // Name : Type
                let name = if let TokenType::IDENTIFIER(n) = &self.current_token().token_type {
                    let s = n.clone();
                    self.advance();
                    s
                } else {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: "identifier for member name".to_string(), line });
                };
                if self.match_token(&TokenType::COLON) {
                    self.advance();
                    if let TokenType::IDENTIFIER(_ty) = &self.current_token().token_type { self.advance(); } else {
                        let line = self.current_token().line;
                        return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: "type name after ':'".to_string(), line });
                    }
                } else {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: ": type".to_string(), line });
                }
                // Optional postfix handlers (Stage-3) directly after block
                if crate::config::env::parser_stage3() && (self.match_token(&TokenType::CATCH) || self.match_token(&TokenType::CLEANUP)) {
                    let mut catch_clauses: Vec<crate::ast::CatchClause> = Vec::new();
                    if self.match_token(&TokenType::CATCH) {
                        self.advance();
                        self.consume(TokenType::LPAREN)?;
                        let (exc_ty, exc_var) = self.parse_catch_param()?;
                        self.consume(TokenType::RPAREN)?;
                        let catch_body = self.parse_block_statements()?;
                        catch_clauses.push(crate::ast::CatchClause { exception_type: exc_ty, variable_name: exc_var, body: catch_body, span: crate::ast::Span::unknown() });
                        self.skip_newlines();
                        if self.match_token(&TokenType::CATCH) {
                            let line = self.current_token().line;
                            return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: "single catch only after member block".to_string(), line });
                        }
                    }
                    let finally_body = if self.match_token(&TokenType::CLEANUP) { self.advance(); Some(self.parse_block_statements()?) } else { None };
                    final_body = vec![ASTNode::TryCatch { try_body: final_body, catch_clauses, finally_body, span: crate::ast::Span::unknown() }];
                }

                // Generate methods per kind
                if kind == "once" {
                    let compute_name = format!("__compute_once_{}", name);
                    let compute = ASTNode::FunctionDeclaration { name: compute_name.clone(), params: vec![], body: final_body, is_static: false, is_override: false, span: Span::unknown() };
                    methods.insert(compute_name.clone(), compute);
                    let key = format!("__once_{}", name);
                    let poison_key = format!("__once_poison_{}", name);
                    let cached_local = format!("__ny_cached_{}", name);
                    let poison_local = format!("__ny_poison_{}", name);
                    let val_local = format!("__ny_val_{}", name);
                    let me_node = ASTNode::Me { span: Span::unknown() };
                    let get_cached = ASTNode::MethodCall { object: Box::new(me_node.clone()), method: "getField".to_string(), arguments: vec![ASTNode::Literal { value: crate::ast::LiteralValue::String(key.clone()), span: Span::unknown() }], span: Span::unknown() };
                    let local_cached = ASTNode::Local { variables: vec![cached_local.clone()], initial_values: vec![Some(Box::new(get_cached))], span: Span::unknown() };
                    let cond_cached = ASTNode::BinaryOp { operator: crate::ast::BinaryOperator::NotEqual, left: Box::new(ASTNode::Variable { name: cached_local.clone(), span: Span::unknown() }), right: Box::new(ASTNode::Literal { value: crate::ast::LiteralValue::Null, span: Span::unknown() }), span: Span::unknown() };
                    let then_ret_cached = vec![ASTNode::Return { value: Some(Box::new(ASTNode::Variable { name: cached_local.clone(), span: Span::unknown() })), span: Span::unknown() }];
                    let if_cached = ASTNode::If { condition: Box::new(cond_cached), then_body: then_ret_cached, else_body: None, span: Span::unknown() };
                    let get_poison = ASTNode::MethodCall { object: Box::new(me_node.clone()), method: "getField".to_string(), arguments: vec![ASTNode::Literal { value: crate::ast::LiteralValue::String(poison_key.clone()), span: Span::unknown() }], span: Span::unknown() };
                    let local_poison = ASTNode::Local { variables: vec![poison_local.clone()], initial_values: vec![Some(Box::new(get_poison))], span: Span::unknown() };
                    let cond_poison = ASTNode::BinaryOp { operator: crate::ast::BinaryOperator::NotEqual, left: Box::new(ASTNode::Variable { name: poison_local.clone(), span: Span::unknown() }), right: Box::new(ASTNode::Literal { value: crate::ast::LiteralValue::Null, span: Span::unknown() }), span: Span::unknown() };
                    let then_throw = vec![ASTNode::Throw { expression: Box::new(ASTNode::Literal { value: crate::ast::LiteralValue::String(format!("once '{}' previously failed", name)), span: Span::unknown() }), span: Span::unknown() }];
                    let if_poison = ASTNode::If { condition: Box::new(cond_poison), then_body: then_throw, else_body: None, span: Span::unknown() };
                    let call_compute = ASTNode::MethodCall { object: Box::new(me_node.clone()), method: compute_name.clone(), arguments: vec![], span: Span::unknown() };
                    let local_val = ASTNode::Local { variables: vec![val_local.clone()], initial_values: vec![Some(Box::new(call_compute))], span: Span::unknown() };
                    let set_call = ASTNode::MethodCall { object: Box::new(me_node.clone()), method: "setField".to_string(), arguments: vec![ASTNode::Literal { value: crate::ast::LiteralValue::String(key.clone()), span: Span::unknown() }, ASTNode::Variable { name: val_local.clone(), span: Span::unknown() }], span: Span::unknown() };
                    let ret_stmt = ASTNode::Return { value: Some(Box::new(ASTNode::Variable { name: val_local.clone(), span: Span::unknown() })), span: Span::unknown() };
                    let try_body = vec![local_val, set_call, ret_stmt];
                    let catch_body = vec![
                        ASTNode::MethodCall { object: Box::new(me_node.clone()), method: "setField".to_string(), arguments: vec![ASTNode::Literal { value: crate::ast::LiteralValue::String(poison_key.clone()), span: Span::unknown() }, ASTNode::Literal { value: crate::ast::LiteralValue::Bool(true), span: Span::unknown() }], span: Span::unknown() },
                        ASTNode::Throw { expression: Box::new(ASTNode::Literal { value: crate::ast::LiteralValue::String(format!("once '{}' init failed", name)), span: Span::unknown() }), span: Span::unknown() }
                    ];
                    let trycatch = ASTNode::TryCatch { try_body, catch_clauses: vec![crate::ast::CatchClause { exception_type: None, variable_name: None, body: catch_body, span: Span::unknown() }], finally_body: None, span: Span::unknown() };
                    let getter_body = vec![local_cached, if_cached, local_poison, if_poison, trycatch];
                    let getter_name = format!("__get_once_{}", name);
                    let getter = ASTNode::FunctionDeclaration { name: getter_name.clone(), params: vec![], body: getter_body, is_static: false, is_override: false, span: Span::unknown() };
                    methods.insert(getter_name, getter);
                } else if kind == "birth_once" {
                    // Self-cycle guard: birth_once cannot reference itself via me.<name>
                    if self.ast_contains_me_field(&final_body, &name) {
                        let line = self.current_token().line;
                        return Err(ParseError::UnexpectedToken { found: self.current_token().token_type.clone(), expected: format!("birth_once '{}' must not reference itself", name), line });
                    }
                    birth_once_props.push(name.clone());
                    let compute_name = format!("__compute_birth_{}", name);
                    let compute = ASTNode::FunctionDeclaration { name: compute_name.clone(), params: vec![], body: final_body, is_static: false, is_override: false, span: Span::unknown() };
                    methods.insert(compute_name.clone(), compute);
                    let key = format!("__birth_{}", name);
                    let me_node = ASTNode::Me { span: Span::unknown() };
                    let get_call = ASTNode::MethodCall { object: Box::new(me_node.clone()), method: "getField".to_string(), arguments: vec![ASTNode::Literal { value: crate::ast::LiteralValue::String(key.clone()), span: Span::unknown() }], span: Span::unknown() };
                    let getter_body = vec![ASTNode::Return { value: Some(Box::new(get_call)), span: Span::unknown() }];
                    let getter_name = format!("__get_birth_{}", name);
                    let getter = ASTNode::FunctionDeclaration { name: getter_name.clone(), params: vec![], body: getter_body, is_static: false, is_override: false, span: Span::unknown() };
                    methods.insert(getter_name, getter);
                } else {
                    // computed
                    let getter_name = format!("__get_{}", name);
                    let getter = ASTNode::FunctionDeclaration { name: getter_name.clone(), params: vec![], body: final_body, is_static: false, is_override: false, span: Span::unknown() };
                    methods.insert(getter_name, getter);
                }
                self.skip_newlines();
                continue;
            }

            // Fallback: method-level postfix catch/cleanup after a method (non-static box)
            if self.parse_method_postfix_after_last_method(&mut methods, &last_method_name)? { continue; }

            // RBRACEに到達していればループを抜ける
            if self.match_token(&TokenType::RBRACE) {
                break;
            }

            // initブロックの処理（initメソッドではない場合のみ）
            if self.parse_init_block_if_any(&mut init_fields, &mut weak_fields)? { continue; }

            // overrideキーワードをチェック
            let mut is_override = false;
            if self.match_token(&TokenType::OVERRIDE) {
                is_override = true;
                self.advance();
            }

            // constructor parsing moved to members::constructors
            if let Some((ctor_key, ctor_node)) = crate::parser::declarations::box_def::members::constructors::try_parse_constructor(self, is_override)? {
                constructors.insert(ctor_key, ctor_node);
                continue;
            }

            // 🚨 birth()統一システム: Box名コンストラクタ無効化
            // Box名と同じ名前のコンストラクタは禁止（birth()のみ許可）
            if let TokenType::IDENTIFIER(id) = &self.current_token().token_type {
                if id == &name && self.peek_token() == &TokenType::LPAREN {
                    return Err(ParseError::UnexpectedToken {
                        expected: format!("birth() constructor instead of {}(). Nyash uses birth() for unified constructor syntax.", name),
                        found: TokenType::IDENTIFIER(name.clone()),
                        line: self.current_token().line,
                    });
                }
            }

            // 通常のフィールド名またはメソッド名、または unified members の先頭キーワードを読み取り
            if let TokenType::IDENTIFIER(field_or_method) = &self.current_token().token_type {
                let field_or_method = field_or_method.clone();
                self.advance();

                // 可視性: public/private ブロック/単行
                if self.parse_visibility_block_or_single(
                    &field_or_method,
                    &mut methods,
                    &mut fields,
                    &mut public_fields,
                    &mut private_fields,
                    &mut last_method_name,
                )? { continue; }

                // Unified Members (header-first) gate: support once/birth_once via members::properties
                if crate::config::env::unified_members() && (field_or_method == "once" || field_or_method == "birth_once") {
                    if crate::parser::declarations::box_def::members::properties::try_parse_unified_property(
                        self,
                        &field_or_method,
                        &mut methods,
                        &mut birth_once_props,
                    )? {
                        last_method_name = None; // do not attach method-level postfix here
                        self.skip_newlines();
                        continue;
                    }
                }

                // メソッド or フィールド（委譲）
                if let Some(method) = crate::parser::declarations::box_def::members::methods::try_parse_method(
                    self,
                    field_or_method.clone(),
                    is_override,
                    &birth_once_props,
                )? {
                    last_method_name = Some(field_or_method.clone());
                    methods.insert(field_or_method, method);
                } else {
                    // フィールド or 統一メンバ（computed/once/birth_once header-first）
                    let fname = field_or_method;
                    if crate::parser::declarations::box_def::members::fields::try_parse_header_first_field_or_property(
                        self,
                        fname,
                        &mut methods,
                        &mut fields,
                    )? {
                        continue;
                    }
                }
            } else {
                return Err(ParseError::UnexpectedToken {
                    expected: "method or field name".to_string(),
                    found: self.current_token().token_type.clone(),
                    line: self.current_token().line,
                });
            }
        }

        self.consume(TokenType::RBRACE)?;

        // 🔥 Override validation
        for parent in &extends {
            self.validate_override_methods(&name, parent, &methods)?;
        }

        // birth_once 相互依存の簡易検出（宣言間の循環）
        if crate::config::env::unified_members() {
            // Collect birth_once compute bodies
            use std::collections::{HashMap, HashSet};
            let mut birth_bodies: HashMap<String, Vec<ASTNode>> = HashMap::new();
            for (mname, mast) in &methods {
                if let Some(prop) = mname.strip_prefix("__compute_birth_") {
                    if let ASTNode::FunctionDeclaration { body, .. } = mast {
                        birth_bodies.insert(prop.to_string(), body.clone());
                    }
                }
            }
            // Build dependency graph: A -> {B | me.B used inside A}
            let mut deps: HashMap<String, HashSet<String>> = HashMap::new();
            let props: HashSet<String> = birth_bodies.keys().cloned().collect();
            for (p, body) in &birth_bodies {
                let used = self.ast_collect_me_fields(body);
                let mut set = HashSet::new();
                for u in used {
                    if props.contains(&u) && u != *p {
                        set.insert(u);
                    }
                }
                deps.insert(p.clone(), set);
            }
            // Detect cycle via DFS
            fn has_cycle(
                node: &str,
                deps: &HashMap<String, HashSet<String>>,
                temp: &mut HashSet<String>,
                perm: &mut HashSet<String>,
            ) -> bool {
                if perm.contains(node) {
                    return false;
                }
                if !temp.insert(node.to_string()) {
                    return true; // back-edge
                }
                if let Some(ns) = deps.get(node) {
                    for n in ns {
                        if has_cycle(n, deps, temp, perm) {
                            return true;
                        }
                    }
                }
                temp.remove(node);
                perm.insert(node.to_string());
                false
            }
            let mut perm = HashSet::new();
            let mut temp = HashSet::new();
            for p in deps.keys() {
                if has_cycle(p, &deps, &mut temp, &mut perm) {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken {
                        found: self.current_token().token_type.clone(),
                        expected: "birth_once declarations must not have cyclic dependencies".to_string(),
                        line,
                    });
                }
            }
        }

        Ok(ASTNode::BoxDeclaration {
            name,
            fields,
            public_fields,
            private_fields,
            methods,
            constructors,
            init_fields,
            weak_fields, // 🔗 Add weak fields to AST
            is_interface: false,
            extends,
            implements,
            type_parameters,
            is_static: false,  // 通常のboxはnon-static
            static_init: None, // 通常のboxはstatic初期化ブロックなし
            span: Span::unknown(),
        })
    }

    /// interface box宣言をパース: interface box Name { methods... }
    pub fn parse_interface_box_declaration(&mut self) -> Result<ASTNode, ParseError> {
        self.consume(TokenType::INTERFACE)?;
        self.consume(TokenType::BOX)?;

        let name = if let TokenType::IDENTIFIER(name) = &self.current_token().token_type {
            let name = name.clone();
            self.advance();
            name
        } else {
            let line = self.current_token().line;
            return Err(ParseError::UnexpectedToken {
                found: self.current_token().token_type.clone(),
                expected: "identifier".to_string(),
                line,
            });
        };

        self.consume(TokenType::LBRACE)?;
        self.skip_newlines(); // ブレース後の改行をスキップ

        let mut methods = HashMap::new();

        while !self.match_token(&TokenType::RBRACE) && !self.is_at_end() {
            self.skip_newlines(); // ループ開始時に改行をスキップ
            if let TokenType::IDENTIFIER(method_name) = &self.current_token().token_type {
                let method_name = method_name.clone();
                self.advance();

                // インターフェースメソッドはシグネチャのみ
                if self.match_token(&TokenType::LPAREN) {
                    self.advance(); // consume '('

                    let mut params = Vec::new();
                    while !self.match_token(&TokenType::RPAREN) && !self.is_at_end() {
                        if let TokenType::IDENTIFIER(param) = &self.current_token().token_type {
                            params.push(param.clone());
                            self.advance();
                        }

                        if self.match_token(&TokenType::COMMA) {
                            self.advance();
                        }
                    }

                    self.consume(TokenType::RPAREN)?;

                    // インターフェースメソッドは実装なし（空のbody）
                    let method_decl = ASTNode::FunctionDeclaration {
                        name: method_name.clone(),
                        params,
                        body: vec![],       // 空の実装
                        is_static: false,   // インターフェースメソッドは通常静的でない
                        is_override: false, // デフォルトは非オーバーライド
                        span: Span::unknown(),
                    };

                    methods.insert(method_name, method_decl);

                    // メソッド宣言後の改行をスキップ
                    self.skip_newlines();
                } else {
                    let line = self.current_token().line;
                    return Err(ParseError::UnexpectedToken {
                        found: self.current_token().token_type.clone(),
                        expected: "(".to_string(),
                        line,
                    });
                }
            } else {
                let line = self.current_token().line;
                return Err(ParseError::UnexpectedToken {
                    found: self.current_token().token_type.clone(),
                    expected: "method name".to_string(),
                    line,
                });
            }
        }

        self.consume(TokenType::RBRACE)?;

        Ok(ASTNode::BoxDeclaration {
            name,
            fields: vec![], // インターフェースはフィールドなし
            public_fields: vec![],
            private_fields: vec![],
            methods,
            constructors: HashMap::new(), // インターフェースにコンストラクタなし
            init_fields: vec![],          // インターフェースにinitブロックなし
            weak_fields: vec![],          // 🔗 インターフェースにweak fieldsなし
            is_interface: true,           // インターフェースフラグ
            extends: vec![],              // 🚀 Multi-delegation: Changed from None to vec![]
            implements: vec![],
            type_parameters: Vec::new(), // 🔥 インターフェースではジェネリクス未対応
            is_static: false,            // インターフェースは非static
            static_init: None,           // インターフェースにstatic initなし
            span: Span::unknown(),
        })
    }
}

impl NyashParser {
    /// Minimal scan: does body contain `me.<field>` access (direct self-cycle guard)
    fn ast_contains_me_field(&self, nodes: &Vec<ASTNode>, field: &str) -> bool {
        fn scan(nodes: &Vec<ASTNode>, field: &str) -> bool {
            for n in nodes {
                match n {
                    ASTNode::FieldAccess { object, field: f, .. } => {
                        if f == field {
                            if let ASTNode::Me { .. } = object.as_ref() {
                                return true;
                            }
                        }
                    }
                    ASTNode::Program { statements, .. } => {
                        if scan(statements, field) { return true; }
                    }
                    ASTNode::If { then_body, else_body, .. } => {
                        if scan(then_body, field) { return true; }
                        if let Some(eb) = else_body { if scan(eb, field) { return true; } }
                    }
                    ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } => {
                        if scan(try_body, field) { return true; }
                        for c in catch_clauses { if scan(&c.body, field) { return true; } }
                        if let Some(fb) = finally_body { if scan(fb, field) { return true; } }
                    }
                    ASTNode::FunctionDeclaration { body, .. } => {
                        if scan(body, field) { return true; }
                    }
                    _ => {}
                }
            }
            false
        }
        scan(nodes, field)
    }

    /// Collect all `me.<field>` accessed in nodes (flat set)
    fn ast_collect_me_fields(&self, nodes: &Vec<ASTNode>) -> std::collections::HashSet<String> {
        use std::collections::HashSet;
        fn scan(nodes: &Vec<ASTNode>, out: &mut HashSet<String>) {
            for n in nodes {
                match n {
                    ASTNode::FieldAccess { object, field, .. } => {
                        if let ASTNode::Me { .. } = object.as_ref() {
                            out.insert(field.clone());
                        }
                    }
                    ASTNode::Program { statements, .. } => scan(statements, out),
                    ASTNode::If { then_body, else_body, .. } => {
                        scan(then_body, out);
                        if let Some(eb) = else_body { scan(eb, out); }
                    }
                    ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } => {
                        scan(try_body, out);
                        for c in catch_clauses { scan(&c.body, out); }
                        if let Some(fb) = finally_body { scan(fb, out); }
                    }
                    ASTNode::FunctionDeclaration { body, .. } => scan(body, out),
                    _ => {}
                }
            }
        }
        let mut hs = HashSet::new();
        scan(nodes, &mut hs);
        hs
    }
}