import java.io.BufferedReader;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Hash {

	// Funktion zum Einlesen eines Files
	public static ArrayList<String> read(String fileName) {

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

		try {
			BufferedReader reader = new BufferedReader(new FileReader(fileName));

			String line = "";

			while (line != null) {

				line = reader.readLine();

				if (line != null) {
					data.add(line);
				}

			}
			reader.close();

		} catch (Exception e) {
			e.printStackTrace();
		}

		return data;
	}

	// Funktion zum Schreiben von Personendaten in einen File
	// k spezifiziert bis zum wievielten Element die Daten in das File geschrieben
	// werden
	public static void write(String fileName, ArrayList<?> data) {

		try {
			BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));

			for (int i = 0; i < data.size(); i++) {
				if (data.get(i) == null) {
					writer.write("\n");
				} else {
					writer.write(data.get(i).toString() + "\n");
				}
			}

			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// Klasse Person
	private static class Person {

		private String name;
		private String state;
		private char gender;
		private int age;
		private int ID;

		// Constructor
		public Person(String name, String state, char gender, int age, int ID) {
			this.name = name;
			this.state = state;
			this.gender = gender;
			this.age = age;
			this.ID = ID;
		}

		public Person(int ID) {
			this.ID = ID;
		}

		public Person() {
			ID = -1;
		}

		public String getName() {
			return name;
		}

		public char getGender() {
			return gender;
		}

		public String getState() {
			return state;
		}

		public int getAge() {
			return age;
		}

		public int getID() {
			return ID;
		}

		public boolean equals(Person other) {
			if (!name.equals(other.getName()))
				return false;

			if (!state.equals(other.getState()))
				return false;

			if (gender != other.getGender())
				return false;

			if (age != other.getAge())
				return false;

			if (ID != other.getID())
				return false;

			return true;
		}

		public String toString() {
			String record = name + " " + state + " " + gender + " " + age + " " + ID;

			if (name == null && state == null && gender == '\u0000' && age == 0)
				record = "" + ID;

			if (ID == -1)
				record = "-1";
			return record;
		}

	}

	private static class HashTable {

		private ArrayList<Person> hashTable;
		private ArrayList<Person> extraTable;
		private int c;
		private int m;

		public HashTable(int m, int c) {
			hashTable = new ArrayList<Person>();
			extraTable = new ArrayList<Person>();

			this.m = m;
			this.c = c;

			for (int i = 0; i < m; i++) {
				hashTable.add(null);
			}
		}

		private int getHash(int ID) {
			int m = hashTable.size();
			int hash = ID % m;
			return hash;
		}

		public void insert(Person p) {
			int ID = p.getID();
			int hash = getHash(ID);
			int jumps = 0;

			while (jumps <= (c * m)) {
				if (hashTable.get((hash + jumps) % m) == null) {
					hashTable.set((hash + jumps) % m, p);
					return;
				}
				jumps = jumps + c;
			}
			extraTable.add(p);
		}

		public void delete(Person p) {
			int ID = p.getID();
			int hash = getHash(ID);

			for (int i = 0; i < hashTable.size(); i++) {
				if (hashTable.get(i) != null) {
					if (hashTable.get(i).equals(p)) {
						hashTable.set(i, null);
						return;
					}
				}
			}

			for (int i = 0; i < extraTable.size(); i++) {
				if (extraTable.get(i).equals(p)) {
					extraTable.remove(i);
					return;
				}
			}
		}

		public Person find(int ID) {
			int hash = getHash(ID);
			int jumps = 0;

			while (jumps <= (c * m)) {
				if (hashTable.get((hash + jumps) % m) != null) {
					if (hashTable.get((hash + jumps) % m).getID() == ID) {
						return hashTable.get((hash + jumps) % m);
					}
				}
				jumps = jumps + c;
			}

			for (int i = 0; i < extraTable.size(); i++) {
				if (extraTable.get(i).getID() == ID)
					return extraTable.get(i);
			}

			return new Person();
		}

		public ArrayList<Person> writeTables() {
			ArrayList<Person> tmp = new ArrayList<>();
			for (int i = 0; i < hashTable.size(); i++) {
				tmp.add(hashTable.get(i));
			}

			tmp.add(new Person(extraTable.size()));

			return tmp;
		}
	}

	public static void main(String args[]) {

		System.out.println("\nHASH ME IF YOU CAN\n");

		if (args.length < 5)
			return;

		// Parameter für Lineares Sondieren
		int c = Integer.parseInt(args[0]);

		// Größe der Hashtabelle
		int m = Integer.parseInt(args[1]);

		System.out.println("c = " + c + "  m = " + m);
		// Eingabedatei1
		String fileName1 = args[2];

		// Datenstruktur zum Verwalten der eingelesenen Elemente
		ArrayList<String> data = read(fileName1);

		// Personendaten
		ArrayList<Person> persons = new ArrayList<>();

		// Konvertierung der eingelesenen Zeichenketten in Personenobjekte
		for (int i = 0; i < data.size(); i++) {

			String[] vpr = null;
			vpr = data.get(i).split("\\s+");

			String name, state;
			char gender;
			int age, ID;

			name = vpr[0];
			state = vpr[1];
			gender = vpr[2].charAt(0);
			age = Integer.parseInt(vpr[3]);
			ID = Integer.parseInt(vpr[4]);

			Person person = new Person(name, state, gender, age, ID);
			persons.add(person);
		}

		// Hashing
		HashTable ht = new HashTable(m, c);

		for (int i = 0; i < persons.size(); i++) {
			System.out.println("Insert no. " + i);
			ht.insert(persons.get(i));
		}

		write(args[4], ht.writeTables());

		// Delete
		for (int i = 1; i < persons.size(); i += 2) {
			System.out.println("Delete Person: " + persons.get(i).toString());
			ht.delete(persons.get(i));
		}

		// ID Liste
		String fileName2 = args[3];
		ArrayList<String> IDdata = read(fileName2);
		ArrayList<Integer> IDs = new ArrayList<>();

		for (int i = 0; i < IDdata.size(); i++) {
			String sID = IDdata.get(i);
			int ID = Integer.parseInt(sID);
			IDs.add(ID);
		}

		// Search in HashTable
		ArrayList<Person> found = new ArrayList<>();
		for (int i = 0; i < IDs.size(); i++) {
			Person p = ht.find(IDs.get(i));
			System.out.println("Found Person: " + p.toString());
			found.add(p);
		}

		write(args[5], found);

	}

}