use crate::common::spans::Span;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "kind")]
pub enum Node {
    File(FileNode),
    Import(ImportNode),
    ImportSpec(ImportSpecNode),
    ServiceDecl(ServiceDeclNode),
    ServiceFnSig(ServiceFnSigNode),
    FnDecl(FnDeclNode),
    TypeDecl(TypeDeclNode),
    TypeBody(TypeBodyNode),
    Block(BlockNode),
    LetStmt(LetStmtNode),
    ExprStmt(ExprStmtNode),
    ReturnStmt(ReturnStmtNode),
    IntLit(IntLitNode),
    FloatLit(FloatLitNode),
    BoundedLit(BoundedLitNode),
    StringLit(StringLitNode),
    Ident(IdentNode),
    Call(CallNode),
    Unary(UnaryNode),
    Binary(BinaryNode),
    Cast(CastNode),
    IfExpr(IfExprNode),
    WhenExpr(WhenExprNode),
    WhenArm(WhenArmNode),
    TypeName(TypeNameNode),
    TypeApp(TypeAppNode),
    Alloc(AllocNode),
    Mutate(MutateNode),
    Borrow(BorrowNode),
    Peek(PeekNode),
    MemberAccess(MemberAccessNode),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FileNode {
    pub span: Span,
    pub imports: Vec<Node>,
    pub decls: Vec<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ImportNode {
    pub span: Span,
    pub spec: Box<Node>, // Must be ImportSpec
    pub from: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ImportSpecNode {
    pub span: Span,
    pub path: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ServiceDeclNode {
    pub span: Span,
    pub vis: String, // "pub" | "mod"
    pub name: String,
    pub extends: Option<String>,
    pub members: Vec<Node>, // ServiceFnSig
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ServiceFnSigNode {
    pub span: Span,
    pub name: String,
    pub params: Vec<ParamNode>,
    pub ret: Box<Node>, // TypeName or TypeApp
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ParamNode {
    pub span: Span,
    pub name: String,
    pub ty: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FnDeclNode {
    pub span: Span,
    pub name: String,
    pub params: Vec<ParamNode>,
    pub ret: Option<Box<Node>>,
    pub else_fallback: Option<Box<Node>>, // Block
    pub body: Box<Node>, // Block
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TypeDeclNode {
    pub span: Span,
    pub vis: Option<String>,
    pub type_kind: String, // "struct" | "contract" | "error"
    pub name: String,
    pub is_host: bool,
    pub body: Box<Node>, // TypeBody
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TypeBodyNode {
    pub span: Span,
    pub members: Vec<TypeMemberNode>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TypeMemberNode {
    pub span: Span,
    pub name: String,
    pub ty: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BlockNode {
    pub span: Span,
    pub stmts: Vec<Node>,
    pub tail: Option<Box<Node>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct LetStmtNode {
    pub span: Span,
    pub name: String,
    pub is_mut: bool,
    pub ty: Option<Box<Node>>,
    pub init: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ExprStmtNode {
    pub span: Span,
    pub expr: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ReturnStmtNode {
    pub span: Span,
    pub expr: Option<Box<Node>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct IntLitNode {
    pub span: Span,
    pub value: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FloatLitNode {
    pub span: Span,
    pub value: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BoundedLitNode {
    pub span: Span,
    pub value: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct StringLitNode {
    pub span: Span,
    pub value: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct IdentNode {
    pub span: Span,
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CallNode {
    pub span: Span,
    pub callee: Box<Node>,
    pub args: Vec<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct UnaryNode {
    pub span: Span,
    pub op: String,
    pub expr: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BinaryNode {
    pub span: Span,
    pub op: String,
    pub left: Box<Node>,
    pub right: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CastNode {
    pub span: Span,
    pub expr: Box<Node>,
    pub ty: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct IfExprNode {
    pub span: Span,
    pub cond: Box<Node>,
    pub then_block: Box<Node>,
    pub else_block: Option<Box<Node>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WhenExprNode {
    pub span: Span,
    pub arms: Vec<Node>, // WhenArm
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WhenArmNode {
    pub span: Span,
    pub cond: Box<Node>,
    pub body: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TypeNameNode {
    pub span: Span,
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TypeAppNode {
    pub span: Span,
    pub base: String,
    pub args: Vec<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct AllocNode {
    pub span: Span,
    pub ty: Box<Node>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MutateNode {
    pub span: Span,
    pub target: Box<Node>,
    pub binding: String,
    pub body: Box<Node>, // BlockNode
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BorrowNode {
    pub span: Span,
    pub target: Box<Node>,
    pub binding: String,
    pub body: Box<Node>, // BlockNode
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PeekNode {
    pub span: Span,
    pub target: Box<Node>,
    pub binding: String,
    pub body: Box<Node>, // BlockNode
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MemberAccessNode {
    pub span: Span,
    pub object: Box<Node>,
    pub member: String,
}