Register

REGISTER MAIN KLASS

// Felix Vejdegren || Jack Hällström || Douglas Hammarstam
// feve5814@student.su.se || jaha4972@student.su.se || doha6991@student.su.se

import java.util.*;

public class Register {
    private Scanner keyboard = new Scanner(System.in);


    private List<Event> eventList = new ArrayList<>();
    private List<Participant> participantList = new ArrayList<>();



    private int participantNumber = 99;


    private String readCommand() {

        System.out.println("Vad vill du göra?\n 1: Lägga till gren\n 2: Registrera ny deltagare\n 3: Ta bort deltagare\n 4: Registrera resultat\n 5: Se resultatlista för deltagare\n 6: se resultatlista för specifik gren\n 7: Skicka meddelande\n 8: Avsluta");
        return inputStrings("Skriv ditt val här: ");
    }

    private boolean useCommand(String command) {

        switch (command) {
            case "1":
            case "Add event":
                addEvent();
                break;
            case "2":
            case "Add participant":
                addParticipant();
                break;
            case "3":
            case "Remove participant":
                removeParticipant();
                break;
            case "4":
            case "Add result":
                addResult();
                break;
            case "5":
            case "Participant":
                viewParticipant();
                break;
            case "7":
                System.out.println(eventList);
                System.out.println(participantList);
            case "Exit":
                System.out.println("Program closing, goodbye!");
                return false;

            default:
                if (command.startsWith("Message")) {
                    message(command);
                } else if (eventExistsStartMenu(command)) {
                    viewEvent(command);
                }else{
                    System.out.println("Error, wrong command");
                }
        }
        return true;
    }

    private void addEvent() {

        String eventNameTemp = inputStrings("Event name: ");
        while(eventNameTemp.trim().isEmpty() || eventNameTemp.isEmpty()){
            System.out.println("Error: name can't be empty");
            eventNameTemp = inputStrings("Event name: ");
        }
        boolean eventAlreadyExists = false;

        for (Event e : eventList){
            if (eventNameTemp.equals(e.getEventName())){
                eventAlreadyExists = true;
                break;
            }
        }
        if(eventAlreadyExists){
            System.out.println(eventNameTemp + " has already been added");
        }else{
            int attemptsAllowedTemp = inputInts("Attempts allowed: ");
            while (attemptsAllowedTemp <= 0){
                attemptsAllowedTemp = inputInts("Attempts allowed: ");
            }
            System.out.println(eventNameTemp + " with " + attemptsAllowedTemp + " attempts allowed created");
            eventList.add(new Event(eventNameTemp,attemptsAllowedTemp));
        }

    }

    private void addParticipant() {

        String firstName = inputStrings("First name: ");
        while (firstName.trim().isEmpty()) {
            System.out.println("Error: name can't be empty!");
            firstName = inputStrings("First name: ");
        }


        String lastName = inputStrings("Last name: ");
        while (lastName.trim().isEmpty()) {
            System.out.println("Error: name can't be empty!");
            lastName = inputStrings("Last name: ");
        }


        String team = inputStrings("Team: ");
        while (team.trim().isEmpty()) {
            System.out.println("Error: name can't be emtpy!");
            team = inputStrings("Team: ");
        }

        participantNumber++;

        participantList.add(new Participant(firstName, lastName, team, participantNumber));

        System.out.println(participantList.get(participantList.size() - 1) + " added");

    }

    private void removeParticipant() {

        int participantToDelete = inputInts("Number: ");
        if(removeParticipantFromList(participantToDelete)){
            findResultAndRemoveResult(findParticipant(participantToDelete), participantToDelete);
        }else{
            System.out.println("Error: no participant with number " + participantToDelete + " exists");

        }
    }

    private void addResult(){

        int participantNumber = inputInts("Number: ");
        if(!participantExists(participantNumber)){
            System.out.println("Error: no participant with number " + participantNumber + " found!");
            return;
        }
        String eventName = inputStrings("Event: ");
        if(!eventExists(eventName)){
            System.out.println("Error: no event called \"" + eventName + "\" found!");
            return;
        }
        Participant p = addResultParticipant(participantNumber);
        Event e = findEvent(eventName);
        if(eventExists(eventName)&& findAttemptsAllowed(eventName) > countTries(getResultsInEvent(getParticipantResults(participantNumber, eventName), eventName))){
            double t = getResult(inputDoubles("Results for " + getName(participantNumber) + " from " + p.getTeam() + " in " + eventName + ": "), participantNumber, p, eventName);


            setResult(participantNumber, new Result(t, findEvent(eventName)));

            System.out.println("The result for " + getName(participantNumber) + " has been added");
        }else{
            System.out.println("Error: " + getName(participantNumber) + " from " + p.getTeam() + " has already made " + e.getAttemptsAllowed() + " attempts in " + eventName);
        }


    }


    private void setResult(int participantNumber, Result r){
        for (Participant p : participantList){
            if(p.getNumber() == participantNumber){
                p.setResult(participantNumber, r);
            }

        }
    }

    private void viewParticipant(){

        int inputViewParticipant = inputInts("Number: ");
        if(!participantExists(inputViewParticipant)) {
            System.out.println("Error: no participant with number " + inputViewParticipant + " found!");
            return;
        }
        for (Event e : eventList){
            if(didParticipate(inputViewParticipant, e.getEventName())){
                System.out.print("Results for " + getName(inputViewParticipant) + " in " + e.getEventName() + ": ");
                List<Result> results = getParticipantResults(inputViewParticipant, e.getEventName());

                for (Result r : resultList){
                    System.out.print(r.getResult() + ", ");
                }
                System.out.println(" ");
            }
        }


    }

    private void viewEvent(String eventName){

        Result[] resultsArray = convertListToArray(keepBestResults(bubbleSortList(sortAlphabetically(getEventResults(eventName)))));
        int[] placements = new int[keepBestResults(bubbleSortList(sortAlphabetically(getEventResults(eventName)))).size()];
        if(placements.length != 0)
            placements[0] = 1;

        for (int i = 1; i < placements.length; i++) {
            placements[i] = resultsArray[i].getResult() == resultsArray[i - 1].getResult() ? placements[i - 1] : i + 1;
        }

        for (int i = 0; i < resultsArray.length; i++) {
            System.out.print(placements[i] + ": ");
            System.out.println(resultsArray[i].getResult() + " " + getFullNameFromResults(resultsArray[i]) + " " + getTeamFromResutls(resultsArray[i]));
        }

        getFullNameFromResults(resultsArray[0]);
    }

    private List<Result> getEventResults(String eventNameInput) {
        List<Result> eventResults = new ArrayList<>();
        for(Result r : resultList){
            if(eventNameInput.equals(r.getEventName(findEvent(eventNameInput)))){
                eventResults.add(r);

            }
        }
        return eventResults;

    }

    private List<Result> sortAlphabetically(List<Result> listToSort){

        Collections.sort(listToSort, new Comparator<Result>() {
            public int compare(Result r1, Result r2) {
                return r1.getFullName(r1).compareTo(r2.getFullName(r2));

            }
        });

        return listToSort;
    }

    private List<Result> bubbleSortList(List<Result> listToSort){
        int n = listToSort.size();
        Result temp;

        for (Result r : listToSort) {
            for (int i = 0; i < n; i++) {
                for (int j = 1; j < (n - i); j++) {
                    if (listToSort.get(j - 1).getResult() < listToSort.get(j).getResult()) {
                        temp = listToSort.get(j - 1);
                        listToSort.set(j - 1, listToSort.get(j));
                        listToSort.set(j, temp);
                    }
                }
            }
        }
        return listToSort;
    }

    private List<Result> keepBestResults(List<Result> sortedList){

        List<Result> finishedList = new ArrayList<>();

        for (Result r : sortedList){
            boolean exists = false;
            if(finishedList.isEmpty()){
                finishedList.add(r);
            }else{
                for (Result t : finishedList){
                    if(r.getParticipantNumber(r) == t.getParticipantNumber(t)){
                        exists = true;
                    }
                }
                if(!exists){
                    finishedList.add(r);
                }
            }
        }
        return finishedList;
    }

    private Result [] convertListToArray (List finishedList){
        Result[] resultArray = new Result[finishedList.size()];
        finishedList.toArray(resultArray);
        return resultArray;
    }

    private String getFullNameFromResults(Result t){
        for (Result r : resultList){
            return r.getFullName(r);
        }
        return null;
    }

    private String getTeamFromResutls(Result t){
        for (Result r : resultList){
            return r.getTeamName(r);
        }
        return null;
    }

    private boolean removeParticipantFromList (int participantNumber){
        for (Participant p : participantList){
            if(p.getNumber() == participantNumber){
                System.out.println(p.getFullName() + " from " + p.getTeam() + " with number " + participantNumber + " removed");
                participantList.remove(p);
                return true;
            }
        }
        return false;
    }

    private boolean didParticipate(int viewParticipant, String eventName){

        for (Result r : resultList){
            if (viewParticipant == r.getParticipantNumber(findParticipant(viewParticipant)) && r.getEventName(findEvent(eventName)).equals(eventName))
                return true;
        }
        return false;
    }

    private boolean participantExists (int participantNumber){

        for (Participant o : participantList){
            if(o.getNumber() == participantNumber){
                return true;
            }
        }
        return false;
    }

    private Participant findParticipant(int participantNumber){
        for (Participant o : participantList){
            if(o.getNumber() == participantNumber){
                return o;
            }
        }
        return null;
    }

    private List<Result> findResultAndRemoveResult(Participant p, int participantNumber){
        List <Result> resultListNew = new ArrayList<>();
        for (Result r : resultList){
            if(participantNumber != r.getParticipantNumber(p)){
                resultListNew.add(r);
            }

        }
        resultList = resultListNew;
        return resultList;
    }

    private boolean eventExists(String eventName){
        boolean exists = false;

        for (Event e : eventList){
            if(eventName.equals(e.getEventName())) {
                exists = true;
                break;
            }else{
                exists = false;
            }
        }
        return exists;
    }

    private Participant addResultParticipant(int participantNumber) {
        Participant o = null;
        for (Participant p : participantList) {
            if (participantNumber != p.getNumber()) {
                o = null;
            } else {
                o = p;
                return o;
            }
        }
        return o;
    }

    private Event findEvent(String eventName){
        Event w = null;
        for (Event e : eventList){
            if(!eventName.equals(e.getEventName())){
                w = null;
            }else{
                w = e;
                return w;
            }
        }
        return w;
    }

    private int findAttemptsAllowed(String eventName){
        for (Event e : eventList){
            if(e.getEventName().equals(eventName)){
                return e.getAttemptsAllowed();
            }
        }
        return 0;
    }

    private List<Result> getParticipantResults(int viewParticipant, String eventName){
        List <Result> participantResults = new ArrayList<>();
        Participant o = null;
        Event w = null;
        for (Participant p : participantList) {
            if (viewParticipant == p.getNumber()) {
                o = p;
            }
        }
        for (Event e : eventList){
            if(eventName.equals(e.getEventName())){
                w=e;
            }
        }

        for(Result r : resultList){
            if(r.getParticipantNumber(o) == viewParticipant && r.getEventName(w).equals(eventName)){
                participantResults.add(r);
            }
        }
        return participantResults;
    }

    private List<Result>getResultsInEvent(List<Result> participantResults, String eventName){
        List<Result> participantResultsPerEvent = new ArrayList<>();

        Event w = null;
        for (Event e : eventList){
            if(eventName.equals(e.getEventName())){
                w = e;
            }
        }

        for (Result r : participantResults){
            if(r.getEventName(w).equals(eventName)){
                participantResultsPerEvent.add(r);
            }
        }
        return participantResultsPerEvent;
    }

    private int countTries(List<Result> participantResultsPerEvent){
        return participantResultsPerEvent.size();
    }

    private double getResult(double result, int startNumber, Participant o, String eventName) {

        while (result < 0) {
            System.out.println("Error: must be greater than or equal to zero!");
            result = inputDoubles("Results for " + getName(startNumber) + " from " + o.getTeam() + " in " + eventName + ": ");
        }

        return result;
    }

    private boolean eventExistsStartMenu(String command){
        for (Event e : eventList){
            if(command.equals(e.getEventName())){
                return true;
            }
        }
        return false;
    }

    private void message(String command) {

        String cutMessage = command.substring(8, Math.min(command.length(), 62));

        if (cutMessage.length() % 2 == 0) {
            int paddingNeededPerSide = (58 - cutMessage.length()) / 2;
            String paddingLeftSide = String.format("%" + paddingNeededPerSide + "s", "");
            String paddingRightSide = String.format("%-" + paddingNeededPerSide + "s", "");

            System.out.println("############################################################");
            System.out.println("#                                                          #");
            System.out.println("#" + paddingLeftSide + cutMessage.toUpperCase() + paddingRightSide + "#");
            System.out.println("#                                                          #");
            System.out.println("############################################################");
        } else {
            int paddingNeededPerSide = (58 - cutMessage.length()) / 2;
            String paddingLeftSide = String.format("%" + paddingNeededPerSide + "s", "");
            String paddingRightSide = String.format("%-" + paddingNeededPerSide + "s", "");

            System.out.println("############################################################");
            System.out.println("#                                                          #");
            System.out.println("#" + paddingLeftSide + cutMessage.toUpperCase() + paddingRightSide + " #");
            System.out.println("#                                                          #");
            System.out.println("############################################################");
        }


    }

    private String getName(int number) {

        String fullName = null;

        for (Participant p : participantList) {
            if (p.getNumber() == number) {
                fullName = p.getFirstName() + " " + p.getLastName();
                return fullName;
            }
        }

        return fullName;
    }

    public String inputStrings(String prompt) {
        System.out.print(prompt);
        String s = keyboard.nextLine().toLowerCase().trim();

        if(s.isEmpty()){
            s = " ";
        }
        String sNormalized = s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
        return sNormalized;
    }

    public int inputInts(String prompt) {
        System.out.print(prompt);
        int i = keyboard.nextInt();
        keyboard.nextLine();
        return i;
    }

    private double inputDoubles(String prompt) {
        System.out.print(prompt);
        double d = keyboard.nextDouble();
        keyboard.nextLine();
        return d;
    }

    private void run() {
        boolean running;

        do {

            String command = readCommand();
            running = useCommand(command);

        } while (running);
    }

    public static void main(String[] args) {
        new Register().run();

    }

}

RESULT KLASS

// Felix Vejdegren || Jack Hällström || Douglas Hammarstam
// feve5814@student.su.se || jaha4972@student.su.se || doha6991@student.su.se

public class Result {

    private double result;
    //private Participant p;
    private Event e;

    public Result(double result, Event e) {
        this.e = e;
        this.result = result;
    }

    public double getResult() {
        return result;
    }

    public void setResult(double result) {
        this.result = result;
    }

    public Event getEvent(Event e) {
        return e;
    }

    public void setEvent(Event e){
        this.e = e;
    }

    public Participant getParticipant(Participant p){
        return p;
    }



    public int getParticipantNumber(Participant p){
        return p.getNumber();

    }

    public String getEventName(Event e){
        return e.getEventName();
    }

    public String toString() {
        return (" " + e + " " + result + " ");
    }


}

EVENT KLASS

// Felix Vejdegren || Jack Hällström || Douglas Hammarstam
// feve5814@student.su.se || jaha4972@student.su.se || doha6991@student.su.se


public class Event {

    private String eventName;
    private int attemptsAllowed;

    public Event(String eventName, int attemptsAllowed) {
        this.eventName = eventName;
        this.attemptsAllowed = attemptsAllowed;
    }

    public String getEventName() {
        return eventName;
    }

    public void setEventName(String eventName) {
        this.eventName = eventName;
    }

    public int getAttemptsAllowed() {
        return attemptsAllowed;
    }

    public void setAttemptsAllowed(int attemptsAllowed) {
        this.attemptsAllowed = attemptsAllowed;
    }

    public String toString() {
        return (eventName + " " + attemptsAllowed);
    }

}

// Felix Vejdegren || Jack Hällström || Douglas Hammarstam
// feve5814@student.su.se || jaha4972@student.su.se || doha6991@student.su.se

import java.util.ArrayList;
import java.util.List;

public class Participant {

    private String firstName;
    private String lastName;
    private String fullName;
    private String team;
    private int number;
    private Result r;


    public Participant(String firstName, String lastName, String team, int number) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.team = team;
        this.number = number;
    }

    public Participant() {

    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFullName() {
        return firstName + " " + lastName;
    }

    public void setFullName() {
        this.fullName = fullName;
    }

    public String getTeam() {
        return team;
    }

    public void setTeam(String team) {
        this.team = team;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Result getResult(){
        return r;
    }

    public void setResult(int participant, Result r){
        if(participant== number){
            this.r = r;
        }




    }

    public String toString() {
        return (firstName + " " + lastName + " from " + team + " with number " + number);
    }
}