package com.vogella.jdt.newelements.handlers;

import java.util.Locale;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;

public class AddPackage {

    @Execute
    public void execute() {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IWorkspaceRoot root = workspace.getRoot();
        IProject[] projects = root.getProjects();
        for (IProject project : projects) {
            try {
                // only work on open projects with the Java nature
                if (project.isOpen() && project.isNatureEnabled(JavaCore.NATURE_ID)) {
                    createPackage(project);
                }
            } catch (CoreException e) {
                e.printStackTrace();
            }
        }
    }

    private void createPackage(IProject project) throws JavaModelException {
        IJavaProject javaProject = JavaCore.create(project);
        IPackageFragmentRoot srcFolder = javaProject.getPackageFragmentRoot(project.getFolder("src"));
        String packageName = project.getName().toLowerCase(Locale.ROOT).replaceAll("[^a-z0-9.]", "");
        // skip projects without a src source folder and names which give no valid package name
        if (!srcFolder.exists() || !JavaConventions.validatePackageName(packageName, JavaCore.VERSION_25,
                JavaCore.VERSION_25).isOK()) {
            return;
        }
        srcFolder.createPackageFragment(packageName, true, null);
    }
}

package com.vogella.jdt.addclasspath.handlers;

import java.util.Arrays;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;

public class GlobalModifyClasspathHandler {

    private static final IPath JUNIT_CONTAINER_PATH = IPath
            .fromPortableString("org.eclipse.jdt.junit.JUNIT_CONTAINER/6");

    @Execute
    public void execute() {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IWorkspaceRoot root = workspace.getRoot();
        IProject[] projects = root.getProjects();
        for (IProject project : projects) {
            try {
                // only work on open projects with the Java nature
                if (project.isOpen() && project.isNatureEnabled(JavaCore.NATURE_ID)) {
                    changeClasspath(project);
                }
            } catch (CoreException e) {
                e.printStackTrace();
            }
        }
    }

    private void changeClasspath(IProject project) throws JavaModelException {
        IJavaProject javaProject = JavaCore.create(project);
        IClasspathEntry[] entries = javaProject.getRawClasspath();
        // a duplicate entry would make setRawClasspath fail
        if (Arrays.stream(entries).anyMatch(entry -> JUNIT_CONTAINER_PATH.equals(entry.getPath()))) {
            return;
        }
        IClasspathEntry[] newEntries = Arrays.copyOf(entries, entries.length + 1);
        newEntries[entries.length] = JavaCore.newContainerEntry(JUNIT_CONTAINER_PATH);
        javaProject.setRawClasspath(newEntries, null);
    }
}

package com.vogella.jdt.addclasspath.handlers;

import java.util.Arrays;

import jakarta.inject.Named;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.e4.core.di.annotations.CanExecute;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.services.IServiceConstants;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.viewers.IStructuredSelection;

public class ModifyClasspathHandler {

    // adjust to the location of the Mockito JAR on your machine
    private static final String MOCKITO_JAR = "/path/to/mockito-core.jar";

    @Execute
    public void execute(@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection) {
        if (selection.getFirstElement() instanceof IJavaElement javaElement) {
            Job job = Job.create("Setting the classpath", monitor -> {
                IJavaProject javaProject = javaElement.getJavaProject();
                IClasspathEntry libraryEntry = JavaCore.newLibraryEntry(IPath.fromOSString(MOCKITO_JAR), null, null);
                try {
                    IClasspathEntry[] entries = javaProject.getRawClasspath();
                    // a duplicate entry would make setRawClasspath fail
                    if (Arrays.stream(entries).anyMatch(entry -> libraryEntry.getPath().equals(entry.getPath()))) {
                        return Status.OK_STATUS;
                    }
                    IClasspathEntry[] newEntries = Arrays.copyOf(entries, entries.length + 1);
                    newEntries[entries.length] = libraryEntry;
                    javaProject.setRawClasspath(newEntries, monitor);
                } catch (JavaModelException e) {
                    return Status.error("Could not set classpath of Java project: " + javaProject.getElementName(), e);
                }
                return Status.OK_STATUS;
            });
            job.schedule();
        }
    }

    @CanExecute
    public boolean canExecute(@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection) {
        return selection.getFirstElement() instanceof IJavaElement;
    }
}

String source = String.join("\n",
        "public class HelloWorld {",
        "    public static void main(String[] args) {",
                  // Insert the following statement.
                  // System.out.println("Hello, World");
        "    }",
        "}");

ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
parser.setSource(source.toCharArray());
parser.setKind(ASTParser.K_COMPILATION_UNIT);

CompilationUnit unit = (CompilationUnit) parser.createAST(new NullProgressMonitor());

unit.accept(new ASTVisitor() {

    @SuppressWarnings("unchecked")
    public boolean visit(MethodDeclaration node) {
        AST ast = node.getAST();

        MethodInvocation methodInvocation = ast.newMethodInvocation();

        // System.out.println("Hello, World")
        QualifiedName qName =
                   ast.newQualifiedName(
                            ast.newSimpleName("System"),
                            ast.newSimpleName("out"));
        methodInvocation.setExpression(qName);
        methodInvocation.setName(ast.newSimpleName("println"));

        StringLiteral literal = ast.newStringLiteral();
        literal.setLiteralValue("Hello, World");
        methodInvocation.arguments().add(literal);

        // Append the statement
        node.getBody().statements().add(ast.newExpressionStatement(methodInvocation));

        return super.visit(node);
    }
});

        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IPath path = IPath.fromPortableString("/com.vogella.example/src/com/vogella/example/Snippet.java");
        IFile file = workspace.getRoot().getFile(path);
        ICompilationUnit element = JavaCore.createCompilationUnitFrom(file);
        ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
        parser.setResolveBindings(true);
        parser.setKind(ASTParser.K_COMPILATION_UNIT);
        parser.setBindingsRecovery(true);
        parser.setSource(element);
        CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);

        ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
        Map<String, String> options = JavaCore.getOptions();
        JavaCore.setComplianceOptions(JavaCore.VERSION_25, options);
        parser.setCompilerOptions(options);
        parser.setStatementsRecovery(true);
        parser.setKind(ASTParser.K_COMPILATION_UNIT);
        java.nio.file.Path sourcePath = java.nio.file.Path.of("tests/resources/Snippet.java");
        String sourceString = java.nio.file.Files.readString(sourcePath);
        parser.setSource(sourceString.toCharArray());
        parser.setUnitName(sourcePath.toAbsolutePath().toString());
        CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);

         Document document = new Document("import java.util.List;\nclass X {}\n");
         ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
         Map<String, String> options = JavaCore.getOptions();
         JavaCore.setComplianceOptions(JavaCore.VERSION_25, options);
         parser.setCompilerOptions(options);
         parser.setSource(document.get().toCharArray());
         CompilationUnit cu = (CompilationUnit) parser.createAST(null);
         AST ast = cu.getAST();
         ImportDeclaration id = ast.newImportDeclaration();
         id.setName(ast.newName(new String[] {"java", "util", "Set"}));
         ASTRewrite rewriter = ASTRewrite.create(ast);
         ListRewrite lrw = rewriter.getListRewrite(cu, CompilationUnit.IMPORTS_PROPERTY);
         lrw.insertLast(id, null);
         TextEdit edits = rewriter.rewriteAST(document, null);
         edits.apply(document);
         assert "import java.util.List;\nimport java.util.Set;\nclass X {}\n".equals(document.get());

    protected void saveChanges(ICompilationUnit cu, IProgressMonitor monitor, final ASTRewrite rewriter,
            ImportRewrite importRewrite) throws CoreException, BadLocationException {
        TextEdit importEdits = importRewrite.rewriteImports(monitor);
        TextEdit edits = rewriter.rewriteAST();
        importEdits.addChild(edits);

        // apply the text edits to the compilation unit
        Document document = new Document(cu.getSource());
        importEdits.apply(document);

        // save the compilation unit
        cu.getBuffer().setContents(document.get());
        cu.save(monitor, true);
    }

protected IMember getIMemberAt(IType type, int lineNumber) throws Exception {
    if (type == null) {
        return null;
    }
    // works for both source and binary types
    ITypeRoot typeRoot = type.getTypeRoot();
    String source = typeRoot.getSource();
    if (source == null) {
        return null;
    }
    // the line number is zero-based
    IRegion region = new Document(source).getLineInformation(lineNumber);
    return typeRoot.getElementAt(region.getOffset()) instanceof IMember member ? member : null;
}

@Override
public void setOptions(CleanUpOptions options) {
    Assert.isLegal(options != null);
    this.options = options;
}

@Override
public CleanUpRequirements getRequirements() {
    boolean requiresAST = options.isEnabled(CLEANUP_COPYRIGHTS_FLAG);
    return new CleanUpRequirements(requiresAST, requiresAST, false, null);
}

@Override
public String[] getStepDescriptions() {
    if (options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
        return new String[] { "Update Copyrights" };
    }
    return null;
}

@Override
public RefactoringStatus checkPreConditions(IJavaProject project, ICompilationUnit[] compilationUnits,
        IProgressMonitor monitor) throws CoreException {
    return new RefactoringStatus();
}

@Override
public RefactoringStatus checkPostConditions(IProgressMonitor monitor) throws CoreException {
    return new RefactoringStatus();
}

@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
    CompilationUnit compilationUnit = context.getAST();
    if (compilationUnit == null) {
        return null;
    }
    TextEdit edit = computeEdit(compilationUnit); // your logic, returns null if there is nothing to fix
    if (edit == null) {
        return null;
    }
    return monitor -> {
        CompilationUnitChange change = new CompilationUnitChange("Update Copyrights",
                context.getCompilationUnit());
        change.setEdit(edit);
        return change;
    };
}

package com.vogella.jdt.quickfix;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
import org.eclipse.jdt.internal.ui.text.correction.AssistContext;
import org.eclipse.jdt.internal.ui.text.java.AbstractJavaCompletionProposal;
import org.eclipse.jdt.ui.actions.AddGetterSetterAction;
import org.eclipse.jdt.ui.text.java.IInvocationContext;
import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
import org.eclipse.jdt.ui.text.java.IProblemLocation;
import org.eclipse.jdt.ui.text.java.IQuickAssistProcessor;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.viewers.StyledString;

@SuppressWarnings("restriction")
public class QuickAssistsProcessorGetterSetter implements IQuickAssistProcessor {

    @Override
    public boolean hasAssists(IInvocationContext context) throws CoreException {
        return findSelectedTypeWithFields(context) != null;
    }

    @Override
    public IJavaCompletionProposal[] getAssists(IInvocationContext context, IProblemLocation[] locations)
            throws CoreException {
        TypeDeclaration typeDeclaration = findSelectedTypeWithFields(context);
        if (typeDeclaration == null) {
            return null;
        }
        return new IJavaCompletionProposal[] {
                createGetterAndSetterProposal(context, typeDeclaration.getName().getIdentifier()) };
    }

    // returns the type whose name is selected, if it declares fields
    private TypeDeclaration findSelectedTypeWithFields(IInvocationContext context) {
        if (context.getCoveringNode() instanceof SimpleName name
                && name.getParent() instanceof TypeDeclaration typeDeclaration
                && typeDeclaration.getFields().length > 0) {
            return typeDeclaration;
        }
        return null;
    }

    private IJavaCompletionProposal createGetterAndSetterProposal(IInvocationContext context, String typeName) {
        return new AbstractJavaCompletionProposal() {
            @Override
            public StyledString getStyledDisplayString() {
                return new StyledString("Generate Getter and Setter for " + typeName);
            }

            @Override
            protected int getPatternMatchRule(String pattern, String string) {
                // no pattern matching, the proposal only opens the "Generate Getters and Setters..." dialog
                return -1;
            }

            @Override
            public void apply(ITextViewer viewer, char trigger, int stateMask, int offset) {
                if (context instanceof AssistContext assistContext
                        && assistContext.getEditor() instanceof CompilationUnitEditor editor) {
                    new AddGetterSetterAction(editor).run();
                }
            }
        };
    }
}

package com.vogella.jdt.quickfix;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.ui.text.java.IInvocationContext;
import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
import org.eclipse.jdt.ui.text.java.IProblemLocation;
import org.eclipse.jdt.ui.text.java.IQuickFixProcessor;

public class ProblemIdQuickFixProcessor implements IQuickFixProcessor {

    @Override
    public boolean hasCorrections(ICompilationUnit unit, int problemId) {
        // print the ID to find out which problem to handle
        System.out.println(problemId);
        return false;
    }

    @Override
    public IJavaCompletionProposal[] getCorrections(IInvocationContext context, IProblemLocation[] locations)
            throws CoreException {
        return null;
    }
}

@Override
public boolean hasCorrections(ICompilationUnit unit, int problemId) {
    String names = Arrays.stream(IProblem.class.getFields())
            .filter(field -> field.getType() == int.class && readInt(field) == problemId)
            .map(Field::getName)
            .collect(Collectors.joining(", "));
    System.out.println(problemId + " " + names);
    return false;
}

private static int readInt(Field field) {
    try {
        return field.getInt(null);
    } catch (IllegalAccessException e) {
        return -1;
    }
}

package com.vogella.jdt.quickfix;

import java.time.Year;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.refactoring.CompilationUnitChange;
import org.eclipse.jdt.ui.cleanup.CleanUpContext;
import org.eclipse.jdt.ui.cleanup.CleanUpOptions;
import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
import org.eclipse.jdt.ui.cleanup.ICleanUp;
import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.text.edits.ReplaceEdit;

public class CopyrightUpdaterCleanUp implements ICleanUp {

    public static final String CLEANUP_COPYRIGHTS_FLAG = "cleanup.update_copyrights";

    private static final Pattern COPYRIGHT = Pattern.compile("Copyright \\(c\\) (\\d{4})(?:, \\d{4})*");

    private CleanUpOptions options;

    @Override
    public void setOptions(CleanUpOptions options) {
        Assert.isLegal(options != null);
        this.options = options;
    }

    @Override
    public CleanUpRequirements getRequirements() {
        return new CleanUpRequirements(false, false, false, null);
    }

    @Override
    public String[] getStepDescriptions() {
        if (options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
            return new String[] { "Update Copyrights" };
        }
        return null;
    }

    @Override
    public RefactoringStatus checkPreConditions(IJavaProject project, ICompilationUnit[] compilationUnits,
            IProgressMonitor monitor) throws CoreException {
        return new RefactoringStatus();
    }

    @Override
    public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
        if (!options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
            return null;
        }
        ICompilationUnit unit = context.getCompilationUnit();
        String source = unit.getSource();
        // only look into the header comment at the start of the file
        if (source == null || !source.startsWith("/*")) {
            return null;
        }
        Matcher matcher = COPYRIGHT.matcher(source);
        matcher.region(0, source.indexOf("*/") + 2);
        if (!matcher.find()) {
            return null;
        }
        String currentYear = String.valueOf(Year.now().getValue());
        String years = matcher.group();
        String lastYear = years.substring(years.length() - 4);
        if (lastYear.equals(currentYear)) {
            return null;
        }
        ReplaceEdit edit = new ReplaceEdit(matcher.start(), matcher.end() - matcher.start(),
                "Copyright (c) " + matcher.group(1) + ", " + currentYear);
        return monitor -> {
            CompilationUnitChange change = new CompilationUnitChange("Update Copyrights", unit);
            change.setEdit(edit);
            return change;
        };
    }

    @Override
    public RefactoringStatus checkPostConditions(IProgressMonitor monitor) throws CoreException {
        return new RefactoringStatus();
    }
}

package com.vogella.jdt.quickfix;

import org.eclipse.jdt.ui.cleanup.CleanUpOptions;
import org.eclipse.jdt.ui.cleanup.ICleanUpOptionsInitializer;

public class CopyrightOptionsInitializer implements ICleanUpOptionsInitializer {

    @Override
    public void setDefaultOptions(CleanUpOptions options) {
        options.setOption(CopyrightUpdaterCleanUp.CLEANUP_COPYRIGHTS_FLAG, CleanUpOptions.TRUE);
    }
}

package com.vogella.jdt.quickfix;

import java.time.Year;

import org.eclipse.jdt.ui.cleanup.CleanUpOptions;
import org.eclipse.jdt.ui.cleanup.ICleanUpConfigurationUI;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;

public class CopyrightTabPage implements ICleanUpConfigurationUI {

    private CleanUpOptions options;

    @Override
    public void setOptions(CleanUpOptions options) {
        this.options = options;
    }

    @Override
    public Composite createContents(Composite parent) {
        Composite result = new Composite(parent, SWT.NONE);
        result.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
        GridLayout layout = new GridLayout(1, false);
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        result.setLayout(layout);

        Group group = new Group(result, SWT.NONE);
        group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
        group.setLayout(new GridLayout(1, false));
        group.setText("Copyright Update");

        Button updateCheckbox = new Button(group, SWT.CHECK);
        updateCheckbox.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false));
        updateCheckbox.setText("Update the Copyrights");
        updateCheckbox.setSelection(options.isEnabled(CopyrightUpdaterCleanUp.CLEANUP_COPYRIGHTS_FLAG));
        updateCheckbox.addSelectionListener(SelectionListener.widgetSelectedAdapter(e -> options.setOption(
                CopyrightUpdaterCleanUp.CLEANUP_COPYRIGHTS_FLAG,
                updateCheckbox.getSelection() ? CleanUpOptions.TRUE : CleanUpOptions.FALSE)));

        return result;
    }

    @Override
    public int getCleanUpCount() {
        return 1;
    }

    @Override
    public int getSelectedCleanUpCount() {
        return options.isEnabled(CopyrightUpdaterCleanUp.CLEANUP_COPYRIGHTS_FLAG) ? 1 : 0;
    }

    @Override
    public String getPreview() {
        String years = options.isEnabled(CopyrightUpdaterCleanUp.CLEANUP_COPYRIGHTS_FLAG)
                ? "2005, " + Year.now().getValue()
                : "2005";
        return """
                /*******************************************************************************
                 * Copyright (c) %s vogella GmbH and others.
                 *
                 * This program and the accompanying materials
                 * are made available under the terms of the Eclipse Public License 2.0
                 * which accompanies this distribution, and is available at
                 * https://www.eclipse.org/legal/epl-2.0/
                 *
                 * SPDX-License-Identifier: EPL-2.0
                 *******************************************************************************/
                """.formatted(years);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<templates>
    <template name="localvariable" description="Local Variable"
        id="org.eclipse.jdt.ui.templates.localvariable" context="java-statements"
        enabled="true" autoinsert="false">
        ${variabletype} ${myvar:newName(var)} = new ${variabletype}(${cursor});
    </template>

    <template name="string" description="String (empty)"
        id="org.eclipse.jdt.ui.templates.emptystring" context="java-statements"
        enabled="true" autoinsert="false">
        String ${myvar:newName(var)} = "";
    </template>

    <template name="arrayexample" description="Creates an Array with some example content"
        id="org.eclipse.jdt.ui.templates.arrayexample" context="java-statements"
        enabled="true" autoinsert="false">
        String[] ${myvar:newName(var)} =
        new String[] {"Windows 7", "macOS", "Debian", "Ubuntu", "Redhat",
        "Android", "iPhone", "Suse", "Windows XP", "Windows Mobile", "OS/2", "WebOS"};
    </template>

</templates>

   <extension
         point="org.eclipse.ui.editors.templates">
      <include
            file="additional-templates.xml">
      </include>
   </extension>