import {DocComment} from ast;

// == Compilation units ==

struct JavaCompilationUnit {
    field typeDeclaration: JavaTypeDeclaration;
}

// == Type declarations ==

sum JavaTypeDeclaration {
    variant JavaClassDeclaration;
    variant JavaEnumDeclaration;
    variant JavaInterfaceDeclaration;
    variant JavaRecordDeclaration;

    field type: JavaTypeRef;
}

struct JavaClassDeclaration {
    field type: JavaTypeRef;
    field implementsTypes: List[JavaTypeRef];
    field body: List[JavaClassBodyDeclaration];
    field docComment: DocComment;
}

struct JavaEnumDeclaration {
    field type: JavaTypeRef;
    field constants: List[JavaEnumConstant];
    field docComment: DocComment;
}

struct JavaEnumConstant {
    field name: JavaIdentifier;
}

struct JavaInterfaceDeclaration {
    field type: JavaTypeRef;
    field openness: JavaInterfaceOpenness;
    field typeParameters: List[JavaTypeParameter];
    field permitsTypes: List[JavaTypeRef];
    field body: List[JavaClassBodyDeclaration];
    field docComment: DocComment;
}

enum JavaInterfaceOpenness {
    variant open;
    variant sealed;
}

struct JavaRecordComponent {
    field type: JavaTypeRef;
    field name: JavaIdentifier;
}

struct JavaRecordDeclaration {
    field type: JavaTypeRef;
    field typeParameters: List[JavaTypeParameter];
    field components: List[JavaRecordComponent];
    field implementsTypes: List[JavaTypeRef];
    field body: List[JavaClassBodyDeclaration];
    field docComment: DocComment;
}

// == Type declaration bodies ==

// TODO: allow JavaClassBodyDeclaration to extend JavaTypeDeclaration
sum JavaClassBodyDeclaration {
    variant JavaClassDeclaration;
    variant JavaConstructorDeclaration;
    variant JavaFieldDeclaration;
    variant JavaInterfaceDeclaration;
    variant JavaMethodDeclaration;
    variant JavaRecordDeclaration;
}

struct JavaConstructorDeclaration {
    field typeName: JavaIdentifier;
    field visibility: JavaVisibility;
    field params: List[JavaParam];
    field body: JavaBlock;
}

struct JavaFieldDeclaration {
    field visibility: JavaVisibility;
    field kind: JavaMemberKind;
    field type: JavaTypeRef;
    field name: JavaIdentifier;
    field initializer: Option[JavaExpression];
}

struct JavaMethodDeclaration {
    field name: JavaIdentifier;
    field visibility: JavaVisibility;
    field kind: JavaMemberKind;
    field typeParameters: List[JavaTypeParameter];
    field returnType: JavaTypeRef;
    field params: List[JavaParam];
    field throws: List[JavaTypeRef];
    field body: Option[JavaBlock];
}

// == Methods ==

enum JavaMemberKind {
    variant static;
    variant instance;
}

struct JavaParam {
    field type: JavaTypeRef;
    field name: JavaIdentifier;
}

// == Type references ==

native JavaTypeRef {
}

// == Type parameters ==

struct JavaTypeParameter {
    field name: JavaIdentifier;
}

// == Visibility ==

enum JavaVisibility {
    variant public;
    variant private;
}

// == Statements ==

struct JavaBlock {
    field statements: List[JavaBlockStatement];
}

sum JavaBlockStatement {
    variant JavaBasicForStatement;
    variant JavaBlock;
    variant JavaEnhancedForStatement;
    variant JavaExpressionStatement;
    variant JavaIfStatement;
    variant JavaLocalVariableDeclaration;
    variant JavaReturn;
    variant JavaSwitchStatement;
    variant JavaThrowStatement;
    variant JavaYieldStatement;
}

struct JavaBasicForStatement {
    field init: Option[JavaLocalVariableDeclaration];
    field condition: Option[JavaExpression];
    field update: Option[JavaExpression];
    field body: JavaBlock;
}

struct JavaEnhancedForStatement {
    field elementType: Option[JavaTypeRef];
    field elementName: JavaIdentifier;
    field elements: JavaExpression;
    field body: JavaBlock;
}

struct JavaExpressionStatement {
    field expression: JavaExpression;
}

struct JavaIfStatement {
    field condition: JavaExpression;
    field ifTrue: JavaBlock;
    field ifFalse: JavaBlock;
}

struct JavaLambdaExpression {
    field params: List[JavaParam];
    field body: JavaBlock;
}

struct JavaLocalVariableDeclaration {
    field type: Option[JavaTypeRef];
    field name: JavaIdentifier;
    field initializer: Option[JavaExpression];
}

struct JavaReturn {
    field value: JavaExpression;
}

struct JavaSwitchStatement {
    field selectorExpression: JavaExpression;
    field rules: List[JavaSwitchRule];
}

struct JavaSwitchRule {
    field label: JavaSwitchLabel;
    field body: JavaBlock;
}

sum JavaSwitchLabel {
    variant JavaCaseConstant;
    variant JavaCaseDefault;
    variant JavaCasePattern;
}

struct JavaCaseConstant {
    field value: JavaExpression;
}

struct JavaCaseDefault {
}

struct JavaCasePattern {
    field pattern: JavaPattern;
}

struct JavaThrowStatement {
    field expression: JavaExpression;
}

struct JavaYieldStatement {
    field expression: JavaExpression;
}

// == Patterns ==

struct JavaPattern {
    field type: JavaTypeRef;
    field variableName: JavaIdentifier;
}

// == Expressions ==

sum JavaExpression {
    variant JavaArrayAccess;
    variant JavaBinaryOperation;
    variant JavaBooleanLiteral;
    variant JavaCast;
    variant JavaClassLiteral;
    variant JavaFieldAccess;
    variant JavaInstanceofExpression;
    variant JavaIntegerLiteral;
    variant JavaLambdaExpression;
    variant JavaMethodCall;
    variant JavaMethodRef;
    variant JavaNewExpression;
    variant JavaNullLiteral;
    variant JavaPostfixExpression;
    variant JavaRef;
    variant JavaStaticFieldAccess;
    variant JavaStaticMethodCall;
    variant JavaStringLiteral;
    variant JavaSwitchExpression;
    variant JavaTernaryConditional;
}

struct JavaArrayAccess {
    field arrayReference: JavaExpression;
    field index: JavaExpression;
}

struct JavaBinaryOperation {
    field operator: JavaBinaryOperator;
    field left: JavaExpression;
    field right: JavaExpression;
}

enum JavaBinaryOperator {
    variant add;
    variant assign;
    variant bitwiseAnd;
    variant bitwiseOr;
    variant equalTo;
    variant greaterThan;
    variant greaterThanOrEqual;
    variant leftShift;
    variant lessThan;
    variant lessThanOrEqual;
    variant logicalAnd;
    variant multiply;
    variant notEqualTo;
    variant unsignedRightShift;
}

struct JavaBooleanLiteral {
    field value: Bool;
}

struct JavaCast {
    field type: JavaTypeRef;
    field operand: JavaExpression;
}

struct JavaClassLiteral {
    field type: JavaTypeRef;
}

struct JavaFieldAccess {
    field receiver: JavaExpression;
    field fieldName: JavaIdentifier;
}

struct JavaInstanceofExpression {
    field value: JavaExpression;
    field pattern: JavaPattern;
}

struct JavaIntegerLiteral {
    field value: Int64;
}

struct JavaMethodCall {
    field receiver: JavaExpression;
    field methodName: JavaIdentifier;
    field args: List[JavaExpression];
}

struct JavaMethodRef {
    field type: JavaTypeRef;
    field methodName: JavaIdentifier;
}

struct JavaNewExpression {
    field type: JavaTypeRef;
    field args: List[JavaExpression];
}

struct JavaNullLiteral {
}

struct JavaPostfixExpression {
    field operator: JavaPostfixOperator;
    field operand: JavaExpression;
}

enum JavaPostfixOperator {
    variant decrement;
    variant increment;
}

struct JavaRef {
    field name: JavaIdentifier;
}

struct JavaStaticFieldAccess {
    field type: JavaTypeRef;
    field fieldName: JavaIdentifier;
}

struct JavaStaticMethodCall {
    field type: JavaTypeRef;
    field typeArgs: List[JavaTypeRef];
    field methodName: JavaIdentifier;
    field args: List[JavaExpression];
}

struct JavaStringLiteral {
    field value: String;
}

struct JavaSwitchExpression {
    field selectorExpression: JavaExpression;
    field rules: List[JavaSwitchRule];
}

struct JavaTernaryConditional {
    field condition: JavaExpression;
    field ifTrue: JavaExpression;
    field ifFalse: JavaExpression;
}

// == Identifiers ==

struct JavaIdentifier {
    field value: String;
}

struct JavaPackageName {
    field parts: List[JavaIdentifier];
}

// == Custom areas ==

struct JavaCustomArea {
    field type: JavaTypeRef;
    field name: String;
}