import type { Node as SyntaxNode } from 'web-tree-sitter';

import { getNodeText, getChildByField } from '../tree-sitter-helpers';

import type { LanguageExtractor } from '../tree-sitter-types';

export const javaExtractor: LanguageExtractor = {

functionTypes: [],

classTypes: ['class_declaration'],

methodTypes: ['method_declaration', 'constructor_declaration'],

interfaceTypes: ['interface_declaration'],

structTypes: [],

enumTypes: ['enum_declaration'],

enumMemberTypes: ['enum_constant'],

typeAliasTypes: [],

importTypes: ['import_declaration'],

callTypes: ['method_invocation'],

variableTypes: ['local_variable_declaration'],

fieldTypes: ['field_declaration'],

nameField: 'name',

bodyField: 'body',

paramsField: 'parameters',

returnField: 'type',

getSignature: (node, source) => {

const params = getChildByField(node, 'parameters');

const returnType = getChildByField(node, 'type');

if (!params) return undefined;

const paramsText = getNodeText(params, source);

return returnType ? getNodeText(returnType, source) + ' ' + paramsText : paramsText;

},

getVisibility: (node) => {

for (let i = 0; i < node.childCount; i++) {

const child = node.child(i);

if (child?.type === 'modifiers') {

const text = child.text;

if (text.includes('public')) return 'public';

if (text.includes('private')) return 'private';

if (text.includes('protected')) return 'protected';

}

}

return undefined;

},

isStatic: (node) => {

for (let i = 0; i < node.childCount; i++) {

const child = node.child(i);

if (child?.type === 'modifiers' && child.text.includes('static')) {

return true;

}

}

return false;

},

extractImport: (node, source) => {

const importText = source.substring(node.startIndex, node.endIndex).trim();

const scopedId = node.namedChildren.find((c: SyntaxNode) => c.type === 'scoped_identifier');

if (scopedId) {

const moduleName = source.substring(scopedId.startIndex, scopedId.endIndex);

return { moduleName, signature: importText };

}

return null;

},

};