use crate::*;

// -----------------------------------------------------------------------------

#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConcurrentAssertionItem {
    Statement(Box<ConcurrentAssertionItemStatement>),
    CheckerInstantiation(Box<CheckerInstantiation>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConcurrentAssertionItemStatement {
    pub nodes: (
        Option<(BlockIdentifier, Symbol)>,
        ConcurrentAssertionStatement,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConcurrentAssertionStatement {
    AssertPropertyStatement(Box<AssertPropertyStatement>),
    AssumePropertyStatement(Box<AssumePropertyStatement>),
    CoverPropertyStatement(Box<CoverPropertyStatement>),
    CoverSequenceStatement(Box<CoverSequenceStatement>),
    RestrictPropertyStatement(Box<RestrictPropertyStatement>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssertPropertyStatement {
    pub nodes: (Keyword, Keyword, Paren<PropertySpec>, ActionBlock),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssumePropertyStatement {
    pub nodes: (Keyword, Keyword, Paren<PropertySpec>, ActionBlock),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverPropertyStatement {
    pub nodes: (Keyword, Keyword, Paren<PropertySpec>, StatementOrNull),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpectPropertyStatement {
    pub nodes: (Keyword, Paren<PropertySpec>, ActionBlock),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverSequenceStatement {
    pub nodes: (
        Keyword,
        Keyword,
        Paren<(
            Option<ClockingEvent>,
            Option<(Keyword, Keyword, Paren<ExpressionOrDist>)>,
            SequenceExpr,
        )>,
        StatementOrNull,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct RestrictPropertyStatement {
    pub nodes: (Keyword, Keyword, Paren<PropertySpec>, Symbol),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyInstance {
    pub nodes: (
        PsOrHierarchicalPropertyIdentifier,
        Option<Paren<Option<PropertyListOfArguments>>>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyListOfArguments {
    Ordered(Box<PropertyListOfArgumentsOrdered>),
    Named(Box<PropertyListOfArgumentsNamed>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyListOfArgumentsOrdered {
    pub nodes: (
        List<Symbol, Option<PropertyActualArg>>,
        Vec<(Symbol, Symbol, Identifier, Paren<Option<PropertyActualArg>>)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyListOfArgumentsNamed {
    pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<PropertyActualArg>>)>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyActualArg {
    PropertyExpr(Box<PropertyExpr>),
    SequenceActualArg(Box<SequenceActualArg>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssertionItemDeclaration {
    PropertyDeclaration(Box<PropertyDeclaration>),
    SequenceDeclaration(Box<SequenceDeclaration>),
    LetDeclaration(Box<LetDeclaration>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyDeclaration {
    pub nodes: (
        Keyword,
        PropertyIdentifier,
        Option<Paren<Option<PropertyPortList>>>,
        Symbol,
        Vec<AssertionVariableDeclaration>,
        PropertySpec,
        Option<Symbol>,
        Keyword,
        Option<(Symbol, PropertyIdentifier)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyPortList {
    pub nodes: (List<Symbol, PropertyPortItem>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyPortItem {
    pub nodes: (
        Vec<AttributeInstance>,
        Option<(Keyword, Option<PropertyLvarPortDirection>)>,
        PropertyFormalType,
        FormalPortIdentifier,
        Vec<VariableDimension>,
        Option<(Symbol, PropertyActualArg)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyLvarPortDirection {
    Input(Box<Keyword>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyFormalType {
    SequenceFormalType(Box<SequenceFormalType>),
    Property(Box<Keyword>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertySpec {
    pub nodes: (
        Option<ClockingEvent>,
        Option<(Keyword, Keyword, Paren<ExpressionOrDist>)>,
        PropertyExpr,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyExpr {
    SequenceExpr(Box<SequenceExpr>),
    Strong(Box<PropertyExprStrong>),
    Weak(Box<PropertyExprWeak>),
    Paren(Box<PropertyExprParen>),
    Not(Box<PropertyExprNot>),
    BinaryProperty(Box<PropertyExprBinaryProperty>),
    BinarySequence(Box<PropertyExprBinarySequence>),
    If(Box<PropertyExprIf>),
    Case(Box<PropertyExprCase>),
    Nexttime(Box<PropertyExprNexttime>),
    SNexttime(Box<PropertyExprSNexttime>),
    Always(Box<PropertyExprAlways>),
    SAlways(Box<PropertyExprSAlways>),
    Eventually(Box<PropertyExprEventually>),
    SEventually(Box<PropertyExprSEventually>),
    AcceptOn(Box<PropertyExprAcceptOn>),
    RejectOn(Box<PropertyExprRejectOn>),
    SyncAcceptOn(Box<PropertyExprSyncAcceptOn>),
    SyncRejectOn(Box<PropertyExprSyncRejectOn>),
    PropertyInstance(Box<PropertyInstance>),
    ClockingEvent(Box<PropertyExprClockingEvent>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprStrong {
    pub nodes: (Keyword, Paren<SequenceExpr>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprWeak {
    pub nodes: (Keyword, Paren<SequenceExpr>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprParen {
    pub nodes: (Paren<PropertyExpr>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprNot {
    pub nodes: (Keyword, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprBinaryProperty {
    pub nodes: (PropertyExpr, Keyword, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprBinarySequence {
    pub nodes: (SequenceExpr, Symbol, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprIf {
    pub nodes: (
        Keyword,
        Paren<ExpressionOrDist>,
        PropertyExpr,
        Option<(Keyword, PropertyExpr)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprCase {
    pub nodes: (
        Keyword,
        Paren<ExpressionOrDist>,
        PropertyCaseItem,
        Vec<PropertyCaseItem>,
        Keyword,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprNexttime {
    pub nodes: (Keyword, Option<Bracket<ConstantExpression>>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSNexttime {
    pub nodes: (Keyword, Option<Bracket<ConstantExpression>>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprAlways {
    pub nodes: (
        Keyword,
        Option<Bracket<CycleDelayConstRangeExpression>>,
        PropertyExpr,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSAlways {
    pub nodes: (
        Keyword,
        Bracket<CycleDelayConstRangeExpression>,
        PropertyExpr,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprEventually {
    pub nodes: (Keyword, Bracket<ConstantRange>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSEventually {
    pub nodes: (
        Keyword,
        Option<Bracket<CycleDelayConstRangeExpression>>,
        PropertyExpr,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprAcceptOn {
    pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprRejectOn {
    pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSyncAcceptOn {
    pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSyncRejectOn {
    pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprClockingEvent {
    pub nodes: (ClockingEvent, PropertyExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyCaseItem {
    Nondefault(Box<PropertyCaseItemNondefault>),
    Default(Box<PropertyCaseItemDefault>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyCaseItemNondefault {
    pub nodes: (List<Symbol, ExpressionOrDist>, Symbol, PropertyExpr, Symbol),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyCaseItemDefault {
    pub nodes: (Keyword, Option<Symbol>, PropertyExpr, Symbol),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceDeclaration {
    pub nodes: (
        Keyword,
        SequenceIdentifier,
        Option<Paren<Option<SequencePortList>>>,
        Symbol,
        Vec<AssertionVariableDeclaration>,
        SequenceExpr,
        Option<Symbol>,
        Keyword,
        Option<(Symbol, SequenceIdentifier)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequencePortList {
    pub nodes: (List<Symbol, SequencePortItem>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequencePortItem {
    pub nodes: (
        Vec<AttributeInstance>,
        Option<(Keyword, Option<SequenceLvarPortDirection>)>,
        SequenceFormalType,
        FormalPortIdentifier,
        Vec<VariableDimension>,
        Option<(Symbol, SequenceActualArg)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceLvarPortDirection {
    Input(Box<Keyword>),
    Inout(Box<Keyword>),
    Output(Box<Keyword>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceFormalType {
    DataTypeOrImplicit(Box<DataTypeOrImplicit>),
    Sequence(Box<Keyword>),
    Untyped(Box<Keyword>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceExpr {
    CycleDelayExpr(Box<SequenceExprCycleDelayExpr>),
    ExprCycleDelayExpr(Box<SequenceExprExprCycleDelayExpr>),
    Expression(Box<SequenceExprExpression>),
    Instance(Box<SequenceExprInstance>),
    Paren(Box<SequenceExprParen>),
    Binary(Box<SequenceExprBinary>),
    FirstMatch(Box<SequenceExprFirstMatch>),
    Throughout(Box<SequenceExprThroughout>),
    ClockingEvent(Box<SequenceExprClockingEvent>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprCycleDelayExpr {
    pub nodes: (
        CycleDelayRange,
        SequenceExpr,
        Vec<(CycleDelayRange, SequenceExpr)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprExprCycleDelayExpr {
    pub nodes: (
        SequenceExpr,
        CycleDelayRange,
        SequenceExpr,
        Vec<(CycleDelayRange, SequenceExpr)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprExpression {
    pub nodes: (ExpressionOrDist, Option<BooleanAbbrev>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprInstance {
    pub nodes: (SequenceInstance, Option<SequenceAbbrev>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprParen {
    pub nodes: (
        Paren<(SequenceExpr, Vec<(Symbol, SequenceMatchItem)>)>,
        Option<SequenceAbbrev>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprBinary {
    pub nodes: (SequenceExpr, Keyword, SequenceExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprFirstMatch {
    pub nodes: (
        Keyword,
        Paren<(SequenceExpr, Vec<(Symbol, SequenceMatchItem)>)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprThroughout {
    pub nodes: (ExpressionOrDist, Keyword, SequenceExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprClockingEvent {
    pub nodes: (ClockingEvent, SequenceExpr),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum CycleDelayRange {
    Primary(Box<CycleDelayRangePrimary>),
    Expression(Box<CycleDelayRangeExpression>),
    Asterisk(Box<CycleDelayRangeAsterisk>),
    Plus(Box<CycleDelayRangePlus>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangePrimary {
    pub nodes: (Symbol, ConstantPrimary),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangeExpression {
    pub nodes: (Symbol, Bracket<CycleDelayConstRangeExpression>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangeAsterisk {
    pub nodes: (Symbol, Bracket<Symbol>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangePlus {
    pub nodes: (Symbol, Bracket<Symbol>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceMethodCall {
    pub nodes: (SequenceInstance, Symbol, MethodIdentifier),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceMatchItem {
    OperatorAssignment(Box<OperatorAssignment>),
    IncOrDecExpression(Box<IncOrDecExpression>),
    SubroutineCall(Box<SubroutineCall>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceInstance {
    pub nodes: (
        PsOrHierarchicalSequenceIdentifier,
        Option<Paren<Option<SequenceListOfArguments>>>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceListOfArguments {
    Ordered(Box<SequenceListOfArgumentsOrdered>),
    Named(Box<SequenceListOfArgumentsNamed>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceListOfArgumentsOrdered {
    pub nodes: (
        List<Symbol, Option<SequenceActualArg>>,
        Vec<(Symbol, Symbol, Identifier, Paren<Option<SequenceActualArg>>)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceListOfArgumentsNamed {
    pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<SequenceActualArg>>)>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceActualArg {
    EventExpression(Box<EventExpression>),
    SequenceExpr(Box<SequenceExpr>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum BooleanAbbrev {
    ConsecutiveRepetition(Box<ConsecutiveRepetition>),
    NonConsecutiveRepetition(Box<NonConsecutiveRepetition>),
    GotoRepetition(Box<GotoRepetition>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceAbbrev {
    pub nodes: (ConsecutiveRepetition,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConsecutiveRepetition {
    Expression(Box<ConsecutiveRepetitionExpression>),
    Asterisk(Box<ConsecutiveRepetitionAsterisk>),
    Plus(Box<ConsecutiveRepetitionPlus>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConsecutiveRepetitionExpression {
    pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConsecutiveRepetitionAsterisk {
    pub nodes: (Bracket<Symbol>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConsecutiveRepetitionPlus {
    pub nodes: (Bracket<Symbol>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonConsecutiveRepetition {
    pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct GotoRepetition {
    pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstOrRangeExpression {
    ConstantExpression(Box<ConstantExpression>),
    CycleDelayConstRangeExpression(Box<CycleDelayConstRangeExpression>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum CycleDelayConstRangeExpression {
    Binary(Box<CycleDelayConstRangeExpressionBinary>),
    Dollar(Box<CycleDelayConstRangeExpressionDollar>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayConstRangeExpressionBinary {
    pub nodes: (ConstantExpression, Symbol, ConstantExpression),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayConstRangeExpressionDollar {
    pub nodes: (ConstantExpression, Symbol, Symbol),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpressionOrDist {
    pub nodes: (Expression, Option<(Keyword, Brace<DistList>)>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssertionVariableDeclaration {
    pub nodes: (VarDataType, ListOfVariableDeclAssignments, Symbol),
}