import java.io.File;
import java.io.FileNotFoundException;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;
import java.util.Scanner;

public class TestDataGenerator {
	private static String database = "jdbc:oracle:thin:@oracle-lab.cs.univie.ac.at:1521:lab";
	private static String user = "a0848868";
	private static String pass = "dbs123";


	//Generiert ein zufaelliges Datum im SQL-Format
	public static String getRandomSQLDate(){
		Random rand = new Random();
		return "to_date('"+(rand.nextInt(28)+1)+"."+(rand.nextInt(12)+1)+"."+(rand.nextInt(3)+14)+"','DD.MM.RR')";
	}

	//Liest eine Datei und gibt eine zufaellige Zeile aus
	public static String getRandomLineFromFile(File f){
		String randomString = null;
	    Random rand = new Random();
	    int n = 0;
	    try{
		    for(Scanner sc = new Scanner(f);sc.hasNext();){
		        ++n;
		        String line = sc.nextLine();
		        if(rand.nextInt(n) == 0)
		        	randomString = line;
		     }
	    }catch(FileNotFoundException e){
	    	e.printStackTrace();
	    }
	    return randomString;
	}

	//Zaehlt eintraege einer Tabelle
	public static int count(String table){
		int count = 0;
		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM " + table);
			if (rs.next()) {
				count = rs.getInt(1);
			}
			rs.close();
			stmt.close();
			con.close();
		}catch(SQLException e){
			e.printStackTrace();
		}
		return count;
	}

	//Rechnet max Wert einer Spalte einer Tabelle
	public static int max(String column, String table){
		int max = 0;
		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT MAX("+column+") FROM " + table);
			if (rs.next()) {
				max = rs.getInt(1);
			}
			rs.close();
			stmt.close();
			con.close();
		}catch(SQLException e){
			e.printStackTrace();
		}
		return max;
	}

	//Fuegt n Spiele zufaellig generiert ein
	public static void insertSpiel(int n){
		File vereine = new File("vereine.txt");
		Random rand = new Random();
		int spielID = max("spielid","spiel");
		//Getting number of games
		System.out.println("Number of datasets before insert: " + count("spiel"));

		//Inserting
		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			for(int i=0;i<n;i++){
				spielID+=1;
				String ergebnis = rand.nextInt(6)+":"+rand.nextInt(6);
				String gegner = getRandomLineFromFile(vereine);
				String spieldatum = getRandomSQLDate();
				String austragungsort = (rand.nextInt()<0) ? "H" : "A";
				String insertSql = "Insert into SPIEL (SPIELID,ERGEBNIS,GEGNER,SPIELDATUM,AUSTRAGUNGSORT) values ('"+spielID+"','"+ergebnis+"','"+gegner+"',"+spieldatum+",'"+austragungsort+"')";
				stmt.executeUpdate(insertSql);
			}
		}catch (SQLException e){
					e.printStackTrace();
		}
		//Counting datasets after insert
		System.out.println("Number of datasets before insert: " + count("spiel"));
	}

	//Fuegt 11 zufaellige Spieler pro Spiel ein
	public static void insertSpielen(){
		HashMap<Integer,String> spielerIDs = new HashMap<Integer,String> ();
		ArrayList<Integer> spielIDs = new ArrayList<Integer>();
		ArrayList<Integer> torwartIDs = new ArrayList<Integer>();
		ArrayList<Integer> abwehrIDs = new ArrayList<Integer>();
		ArrayList<Integer> mittelfeldIDs = new ArrayList<Integer>();
		ArrayList<Integer> angriffIDs = new ArrayList<Integer>();
		ArrayList<Integer> aufstellung = new ArrayList<Integer>();
		Random rand = new Random();
		System.out.println("Number of datasets before insert: " + count("spielen"));

		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT angestellterID,spielerposition FROM Spieler");
			while(rs.next()){
				spielerIDs.put(rs.getInt(1),rs.getString(2));
			}

			for(int y : spielerIDs.keySet()){
				if(spielerIDs.get(y).equals("Torwart")){
					torwartIDs.add(y);
				}else if(spielerIDs.get(y).equals("Abwehr")){
					abwehrIDs.add(y);
				}else if(spielerIDs.get(y).equals("Mittelfeld")){
					mittelfeldIDs.add(y);
				}else if(spielerIDs.get(y).equals("Angriff")){
					angriffIDs.add(y);
				}
			}

			rs = stmt.executeQuery("SELECT spielID FROM Spiel");
			while(rs.next()){
				spielIDs.add(rs.getInt(1));
			}
			rs.close();

			for(int x : spielIDs){
				aufstellung.add(torwartIDs.get((rand.nextInt(torwartIDs.size()))));
				while(aufstellung.size()<5){
					int abwehrID = abwehrIDs.get(rand.nextInt(abwehrIDs.size()));
					if(!aufstellung.contains(abwehrID)){
						aufstellung.add(abwehrID);
					}
				}
				while(aufstellung.size()<9){
					int mittelfeldID = mittelfeldIDs.get(rand.nextInt(mittelfeldIDs.size()));
					if(!aufstellung.contains(mittelfeldID)){
						aufstellung.add(mittelfeldID);
					}
				}
				while(aufstellung.size()<11){
					int angriffID = angriffIDs.get(rand.nextInt(angriffIDs.size()));
					if(!aufstellung.contains(angriffID)){
						aufstellung.add(angriffID);
					}
				}
				for(int y : aufstellung){
					String insertSql = "Insert into SPIELEN (SPIELID,ANGESTELLTERID) values ('"+x+"','"+y+"')";
					stmt.executeUpdate(insertSql);
				}
				aufstellung.clear();
			}
		}catch(SQLException e){
			e.printStackTrace();
		}
		System.out.println("Number of datasets after insert: " + count("spielen"));
	}

	//Fuegt n Zuschauer ein zufaellig auf vorhandene Spiele
	public static void insertZuschauer(int n){
		File vornamen = new File("vornamen.txt");
		File nachnamen = new File("nachnamen.txt");
		Random rand = new Random();

		//Counting datasets before insert
		int zuschauer = max("zuschauernr","zuschauer");
		System.out.println("Number of datasets before insert: " + count("zuschauer"));

		//Getting number of games
		int games = count("spiel");
		System.out.println("Number of games: " + games);

		ArrayList<Integer>spielIDs = new ArrayList<Integer>();
		try {
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT spielID FROM Spiel");
			while(rs.next()){
				spielIDs.add(rs.getInt(1));
			}
			//Inserting
			for(int i=0;i<n;i++){
				zuschauer+=1;
				int spielID = spielIDs.get(rand.nextInt(games));
				String vorname = getRandomLineFromFile(vornamen);
				String nachname = getRandomLineFromFile(nachnamen);
				String insertSql = "Insert into ZUSCHAUER (ZUSCHAUERNR,SPIELID,VORNAME,NACHNAME) values ('"+zuschauer+"','"+spielID+"','"+vorname+"','"+nachname+"')";
				stmt.executeUpdate(insertSql);
			}
		}catch(SQLException e){
			e.printStackTrace();
		}

		//Counting datasets after insert
		zuschauer = count("zuschauer");
		System.out.println("Number of datasets after insert: " + zuschauer);
	}

	//Erstellst n Trainings zufaellig
	public static void insertTraining(int n){
		Random rand = new Random();
		int trainingsID = max("trainingsid","training");
		//Getting number of trainings
		System.out.println("Number of datasets before insert: " + count("training"));

		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			//Inserting
			for(int i=0;i<n;i++){
				trainingsID += 1;
				int trainingsdauer = rand.nextInt(3)+1;
				String trainingsdatum = getRandomSQLDate();
				String[] trainingsarten = {"Lauftraining","Spieltraining","Schusstraining","Torwarttraining"};
				String trainingsart = trainingsarten[rand.nextInt(4)];
				String insertSql = "Insert into TRAINING (TRAININGSID,TRAININGSDAUER,TRAININGSDATUM,TRAININGSART) values ('"+trainingsID+"','"+trainingsdauer+"',"+trainingsdatum+",'"+trainingsart+"')";
				stmt.executeUpdate(insertSql);
			}
		}catch(SQLException e){
			e.printStackTrace();
		}

		//Counting datasets after insert
		System.out.println("Number of datasets before insert: " + count("training"));
	}

	//Fuegt alle Kombinationen von Training, Trainer und Spieler ein
	public static void insertVeranstalten(){
		HashMap<Integer,String>  trainingsIDs = new HashMap<Integer,String> ();
		HashMap<Integer,String>  spielerIDs = new HashMap<Integer,String> ();
		HashMap<Integer,String>  trainerIDs = new HashMap<Integer,String> ();
		System.out.println("Number of datasets before insert: " + count("veranstalten"));
		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT trainingsID,trainingsart FROM training");
			while(rs.next()){
				trainingsIDs.put(rs.getInt(1),rs.getString(2));
			}

			rs = stmt.executeQuery("SELECT angestellterID,spielerposition FROM Spieler");
			while(rs.next()){
				spielerIDs.put(rs.getInt(1),rs.getString(2));
			}

			rs = stmt.executeQuery("SELECT lizenznummer,trainerstelle FROM trainer");
			while(rs.next()){
				trainerIDs.put(rs.getInt(1),rs.getString(2));
			}
			rs.close();

			for(int x : trainingsIDs.keySet()){
				if(trainingsIDs.get(x).equals("Torwarttraining")){
					for(int y : trainerIDs.keySet()){
						if(trainerIDs.get(y).equals("Torwarttrainer")){
							for(int z : spielerIDs.keySet()){
								if(spielerIDs.get(z).equals("Torwart")){
									String insertSql = "Insert into VERANSTALTEN (LIZENZNUMMER,ANGESTELLTERID,TRAININGSID) values ('"+y+"','"+z+"','"+x+"')";
									stmt.executeUpdate(insertSql);
								}
							}
						}
					}
				}else if(trainingsIDs.get(x).equals("Lauftraining")){
					for(int y : trainerIDs.keySet()){
						if(trainerIDs.get(y).equals("Co-Trainer")){
							for(int z : spielerIDs.keySet()){
								String insertSql = "Insert into VERANSTALTEN (LIZENZNUMMER,ANGESTELLTERID,TRAININGSID) values ('"+y+"','"+z+"','"+x+"')";
								stmt.executeUpdate(insertSql);
							}
						}
					}
				}else if(trainingsIDs.get(x).equals("Schusstraining")){
					for(int y : trainerIDs.keySet()){
						if(trainerIDs.get(y).equals("Co-Trainer")){
							for(int z : spielerIDs.keySet()){
								if(!spielerIDs.get(z).equals("Torwart")){
									String insertSql = "Insert into VERANSTALTEN (LIZENZNUMMER,ANGESTELLTERID,TRAININGSID) values ('"+y+"','"+z+"','"+x+"')";
									stmt.executeUpdate(insertSql);
								}
							}
						}
					}
				}else{
					for(int y : trainerIDs.keySet()){
						if(trainerIDs.get(y).equals("Cheftrainer")){
							for(int z : spielerIDs.keySet()){
								String insertSql = "Insert into VERANSTALTEN (LIZENZNUMMER,ANGESTELLTERID,TRAININGSID) values ('"+y+"','"+z+"','"+x+"')";
								stmt.executeUpdate(insertSql);
							}
						}
					}
				}
			}
			stmt.close();
			con.close();
		}catch(SQLException e){
			e.printStackTrace();
		}
		System.out.println("Number of datasets after insert: " + count("veranstalten"));
	}

	//Fuegt zufaellige betreuungs verhaeltnisse ein
	public static void insertBetreuen(int n){
		System.out.println("Number of datasets before insert: " + count("betreuen"));
		ArrayList<Integer> betreuerIDs = new ArrayList<Integer>();
		int anzahlBetreuer = count("betreuer");
		ArrayList<Integer> spielerIDs = new ArrayList<Integer>();
		int anzahlSpieler = count("spieler");
		HashMap<Integer,ArrayList<Integer>> bereitsBetreut = new HashMap<Integer,ArrayList<Integer>>();
		Random rand = new Random();
		int spielerID=0;
		int betreuerID=0;
		try {
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT angestellterid FROM betreuer");
			while(rs.next()){
				betreuerIDs.add(rs.getInt(1));
			}
			rs = stmt.executeQuery("SELECT angestellterid FROM spieler");
			while(rs.next()){
				spielerIDs.add(rs.getInt(1));
			}
			rs = stmt.executeQuery("SELECT * FROM betreuen");
			while(rs.next()){
				spielerID=rs.getInt(1);
				betreuerID=rs.getInt(2);
				if(bereitsBetreut.containsKey(spielerID)){
					bereitsBetreut.get(spielerID).add(betreuerID);
				}else{
					ArrayList<Integer> betreuerIDs2 = new ArrayList<Integer>();
					betreuerIDs2.add(betreuerID);
					bereitsBetreut.put(spielerID,betreuerIDs2);
				}
			}
			rs.close();
			for(int i=0;i<n;i++){
				while(true){
					spielerID = spielerIDs.get(rand.nextInt(anzahlSpieler));
					betreuerID = betreuerIDs.get(rand.nextInt(anzahlBetreuer));
					if(!bereitsBetreut.get(spielerID).contains(betreuerID))
						break;
				}
				String insertSql = "Insert into BETREUEN(BETREUERID,SPIELERID) values ('"+betreuerID+"','"+spielerID+"')";
				stmt.executeUpdate(insertSql);
			}
			stmt.close();
			con.close();
		}catch(SQLException e){
			e.printStackTrace();

		}
		System.out.println("Number of datasets after insert: " + count("betreuen"));
	}

	//http://stackoverflow.com/questions/5868369/how-to-read-a-large-text-file-line-by-line-using-java
	//Fuegt Angestellter und alle anderen mit relativ begrenzten Eintraegen wie Betreuer, Spieler, Trainer, Titel and anfuehren
	public static void insertBasics(){
		System.out.println("Number of datasets before insert: " + (count("angestellter")+count("spieler")+count("trainer")+count("betreuer")+count("titel")+count("betreuertitel")+count("betreuen")+count("anfuehren")));
		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			File angestellter = new File("angestellter.txt");
			Scanner sc = new Scanner(angestellter);
			while(sc.hasNext()){
				stmt.executeUpdate(sc.nextLine());
			}
			sc.close();
			stmt.close();
			con.close();
		}catch (SQLException e){
			e.printStackTrace();
		}catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		System.out.println("Number of datasets after insert: "+ (count("angestellter")+count("spieler")+count("trainer")+count("betreuer")+count("titel")+count("betreuertitel")+count("betreuen")+count("anfuehren")));
	}

	public static void countAll(){
		ArrayList<String> tableNames = new ArrayList<String>();
		try{
			Connection con = DriverManager.getConnection(database,user,pass);
			Statement stmt = con.createStatement();
			ResultSet rs = stmt.executeQuery("SELECT table_name FROM user_tables");
			while(rs.next()){
				tableNames.add(rs.getString(1));
			}
			rs.close();
			stmt.close();
			con.close();
			for(String x : tableNames){
				System.out.println(x + ": " + count(x));
			}
		}catch(SQLException e){
			e.printStackTrace();
		}
	}

	public static void main(String args[]) {
		if(args.length>0){
			if(args[0].equals("count") && args[1].equals("all")){
				countAll();
			}else if(args[0].equals("count")&& args.length==2){
				count(args[1]);
			}else if(args[0].equals("insert") && args[1].equals("spiel")&& args.length==3){
				insertSpiel(Integer.parseInt(args[2]));
			}else if(args[0].equals("insert") && args[1].equals("training") && args.length==3){
				insertTraining(Integer.parseInt(args[2]));
			}else if(args[0].equals("insert") && args[1].equals("zuschauer")&& args.length==3){
				insertZuschauer(Integer.parseInt(args[2]));
			}else if(args[0].equals("insert") && args[1].equals("betreuen")&& args.length==3){
				insertBetreuen(Integer.parseInt(args[2]));
			}else if(args[0].equals("insert") && args[1].equals("spielen")){
				insertSpielen();
			}else if(args[0].equals("insert") && args[1].equals("veranstalten")){
				insertVeranstalten();
			}else if(args[0].equals("insert") && args[1].equals("basics")){
				insertBasics();
			}else{
				System.out.println("Unknown command.");
				System.out.println("Following commands are availibe: ");
				System.out.println("count all, count <Tablename>, insert basics, insert spiel <amount>, insert training <amount>, insert zuschauer <amount>, insert betreuen <amount>, insert spielen, insert veranstalten");
			}
		}else{
			System.out.println("Unknown command.");
			System.out.println("Following commands are availibe: ");
			System.out.println("count all, count <Tablename>, insert basics, insert spiel <amount>, insert training <amount>, insert zuschauer <amount>, insert betreuen <amount>, insert spielen, insert veranstalten");
		}
	}
}