finish implementing core ProteinFactory class functions

import java.io.*;

import java.util.ArrayList;

import java.util.Random;

public class ProteinFactory {

    private static ProteinFactory INSTANCE;

    private ProteinFactory() throws IOException {

    private ProteinFactory() {

        ALANINE.symbol1 = "A";

        CYSTEINE.symbol1 = "C";

        GLYCINE.symbol1 = "G";

        ISOLEUCINE.symbol1 = "I";

        LEUCINE.symbol1 = "L";

        METHIONINE.symbol1 = "M";

        PROLINE.symbol1 = "P";

        SERINE.symbol1 = "S";

        THREONINE.symbol1 = "T";

        VALINE.symbol1 = "V";

    }

    public static ProteinFactory getInstance() throws IOException {

    public static ProteinFactory getInstance() {

        if (INSTANCE == null) {

            INSTANCE = new ProteinFactory();

        }

        return INSTANCE;

    }

    static Random rng = new Random();

    static final AminoAcid ALANINE;

    static final AminoAcid CYSTEINE;

    static final AminoAcid GLYCINE;

    static final AminoAcid LEUCINE;

    static final AminoAcid ISOLEUCINE;

    static final AminoAcid METHIONINE;

    static final AminoAcid PROLINE;

    static final AminoAcid SERINE;

    static final AminoAcid THREONINE;

    static final AminoAcid VALINE;

    static {

        try {

            ALANINE = new AminoAcid("testcases/amino_acid/Alanine.txt",

            ALANINE = new AminoAcid("src/amino_acid/Alanine.txt",

                    2, 12, 10, 5, 4);

            GLYCINE = new AminoAcid("testcases/amino_acid/Glycine.txt",

            CYSTEINE = new AminoAcid("src/amino_acid/Cysteine.txt",

                    2, 12, 10, 5, 4);

            GLYCINE = new AminoAcid("src/amino_acid/Glycine.txt",

                    1, 9, 7, 4, 3);

            LEUCINE = new AminoAcid("src/amino_acid/Leucine.txt",

                    5, 21, 19, 8, 7);

            ISOLEUCINE = new AminoAcid("src/amino_acid/l-Isoleucine.txt",

                    5, 21, 19, 8, 7);

            METHIONINE = new AminoAcid("src/amino_acid/Methionine.txt",

                    5, 19, 17, 8, 7);

            PROLINE = new AminoAcid("src/amino_acid/Proline.txt",

                    5, 13, 16, 3, 7);

            SERINE = new AminoAcid("src/amino_acid/Serine.txt",

                    2, 12, 10, 5, 4);

            THREONINE = new AminoAcid("src/amino_acid/Threonine.txt",

                    3, 15, 13, 6, 5);

            VALINE = new AminoAcid("src/amino_acid/Valine.txt",

                    4, 18, 16, 7, 6);

        } catch (IOException e) {

            throw new RuntimeException(e);

        }

    }

    static final int AMINO_ACID_COUNT = 10;

    static public class AminoAcid {

        int atomCount;

        StringBuffer atomBuffer;

        int bondCount = 0;

        ArrayList<Integer> bondList = new ArrayList<>();

        String name;

        String symbol1;

        ArrayList<Integer> termini = new ArrayList<>();

        int terminusC;

        int terminusHN;

        Integer atomCount;

        StringBuffer atomBuffer = new StringBuffer();

        ArrayList<String> bondList = new ArrayList<>();

        int terminusC;

        boolean complete = false;

        String name;

        int terminusC;

        public Protein(AminoAcid aminoAcid) {

            name = aminoAcid.symbol1;

        public Protein(String name, AminoAcid aminoAcid) {

            int min = Math.min(aminoAcid.terminusHO, aminoAcid.terminusO);

            atomBuffer.append(aminoAcid.atomBuffer, 0, min);

            int max = Math.max(aminoAcid.terminusHO, aminoAcid.terminusO);

            newTerminusC -= (newTerminusC > terminusHO) ? 1 : 0;

            newTerminusC -= (newTerminusC > terminusO) ? 1 : 0;

            terminusC = newTerminusC;

            this.name = name;

        }

        public void print() {

            System.out.println("cannot add to completed protein");

            return;

        }

        protein.name += aminoAcid.symbol1;

        if (isLast) {

            int baseIdx = protein.atomCount;

            int indexH = aminoAcid.atomBuffer.indexOf("H");

            newTerminusC -= (newTerminusC > terminusHN) ? 1 : 0;

            newTerminusC -= (newTerminusC > terminusHO) ? 1 : 0;

            newTerminusC -= (newTerminusC > terminusO) ? 1 : 0;

            protein.terminusC = newTerminusC;

            protein.terminusC = baseIdx + newTerminusC;

        }

    }

    public void generateProtein(int atomCount) {

    public static AminoAcid getAminoAcid(int id) {

        return switch (id) {

            case 9 -> LEUCINE;      // 22

            case 8 -> ISOLEUCINE;   // 22

            case 7 -> METHIONINE;   // 20

            case 6 -> VALINE;       // 19

            case 5 -> THREONINE;    // 17

            case 4 -> PROLINE;      // 17

            case 3 -> SERINE;       // 14

            case 2 -> CYSTEINE;     // 14

            case 1 -> ALANINE;      // 13

            default -> GLYCINE;     // 10

        };

    }

    public static Protein generateProtein(int seed, int chainLen) {

        Protein protein = new Protein(getAminoAcid(seed % AMINO_ACID_COUNT));

        for (int ii = 0; ii < chainLen - 2; ii++) {

            seed /= AMINO_ACID_COUNT;

            addAminoAcid(protein, getAminoAcid(seed % AMINO_ACID_COUNT), false);

        }

        seed /= AMINO_ACID_COUNT;

        addAminoAcid(protein, getAminoAcid(seed % AMINO_ACID_COUNT), true);

        return protein;

    }

    public void generateProteins(int proteinCount, int atomsPerProtein) {

    public static void manySimpleProteins() throws IOException {

        int simpleIdx = 0;

        File simpleDir = new File("../simple");

        for (int ii = 0; ii < 100; ii++) {

            System.out.println(ii + "% done generating simple proteins (< 137 atoms)");

            File simpleDirNested = new File(simpleDir, "simple" + ii);

            simpleDirNested.mkdirs();

            for (int jj = 0; jj < 100000; jj++) {

                Protein protein = generateProtein(simpleIdx, 7);

                protein.write(simpleDirNested.toString());

                simpleIdx++;

            }

        }

    }

    public static void fewComplexProteins() throws IOException {

        int complexIdx = 0;

        File complexDir = new File("../complex");

        for (int ii = 0; ii < 10; ii++) {

            System.out.println(ii + "0% done generating complex proteins (>= 10006 atoms)");

            File complexDirNested = new File(complexDir, "complex" + ii);

            complexDirNested.mkdirs();

            for (int jj = 0; jj < 1000; jj++) {

                Protein protein = generateProtein(complexIdx, 1429);

                protein.name = "protein" + complexIdx;

                protein.write(complexDirNested.toString());

                complexIdx++;

            }

        }

    }

    public static void main(String[] args) throws IOException {

        Protein protein = new Protein("protein1", GLYCINE);

        addAminoAcid(protein, GLYCINE, true);

        protein.write("testcases/protein");

        System.out.println("hello world");

        manySimpleProteins();

        fewComplexProteins();

        System.out.println("goodbye");

    }

}