package ciai;

import java.util.HashSet;
import java.util.Set;

import javax.transaction.Transactional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.web.config.EnableSpringDataWebSupport;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import ciai.model.Account;
import ciai.model.Course;
import ciai.model.Degree;
import ciai.model.Edition;
import ciai.model.Evaluation;
import ciai.model.Professor;
import ciai.model.Role;
import ciai.model.Student;
import ciai.model.StudentEvaluation;
import ciai.model.StudentEvaluationPK;
import ciai.repository.AccountRepository;
import ciai.repository.CourseRepository;
import ciai.repository.DegreeRepository;
import ciai.repository.EditionRepository;
import ciai.repository.EvaluationRepository;
import ciai.repository.ProfessorRepository;
import ciai.repository.RoleRepository;
import ciai.repository.StudentEvaluationRepository;
import ciai.repository.StudentRepository;
import tools.AccountRole;

@SpringBootApplication
@EnableSpringDataWebSupport
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ClassroomApplication implements CommandLineRunner {

	@Autowired
	AccountRepository accRep;
	@Autowired
	StudentRepository studentRep;
	@Autowired
	ProfessorRepository profRep;
	@Autowired
	DegreeRepository degreeRep;
	@Autowired
	CourseRepository courseRep;
	@Autowired
	EditionRepository editionRep;
	@Autowired
	EvaluationRepository evaluationRep;
	@Autowired
	StudentEvaluationRepository studentEvaluationRep;
	@Autowired
	RoleRepository roleRep;

	public static void main(String[] args) {
		SpringApplication.run(ClassroomApplication.class, args);
	}

	@Override
	@Transactional
	public void run(String... strings) throws Exception {

		/**
		 * Create some degrees
		 */
		createDegrees();

		/**
		 * Create some courses
		 */
		createCourses();
		
		/**
		 * Create account roles
		 */
		createRoles();

		/**
		 * Create Accounts
		 */
		createAccounts();

		/**
		 * Create Students
		 */
		Set<Student> students = createStudents();

		/**
		 * Create Professors
		 */
		createProfessors();

		/**
		 * Create Editions
		 */
		createEditions();

		/**
		 * Add Students to Edition
		 */
		addStudentsEditions(students);

		/**
		 * Add Professors to Edition
		 */
		addProfessorsEditions();

		/**
		 * Add Evaluation to Editions
		 */
		addEvaluationsEditions();

		/**
		 * Add Evaluation to Students
		 */
		addEvaluationsStudents();
	}

	private void addEvaluationsStudents() {
		for (Evaluation e : evaluationRep.findAll()) {
			for (Student s : studentRep.findAll()) {
				float value = 0;
				int status = 0;
				if (e.getEdition().getYear() != 2016) {
					value = 11;
					status = 1;
				}
				StudentEvaluationPK sepk = new StudentEvaluationPK(e, s, value, status);
				StudentEvaluation se = new StudentEvaluation(sepk);
				studentEvaluationRep.save(se);
			}
		}

	}

	private void addEvaluationsEditions() {
		for (Edition e : editionRep.findAll()) {
			Set<Evaluation> evaluations = new HashSet<Evaluation>();
			evaluations.add(new Evaluation("MidTerm", 0, (float) 0.3, "24/07/" + e.getYear(), "09:00", e));
			evaluations.add(new Evaluation("Final Test", 0, (float) 0.35, "25/07/" + e.getYear(), "10:00", e));
			evaluations.add(new Evaluation("Exam", 2, (float) 1, "24/07/" + e.getYear(), "09:00", e));
			evaluationRep.save(evaluations);
		}

	}

	private void addProfessorsEditions() {
		int count = 0;

		for (Edition e : editionRep.findAll()) {
			Set<Professor> cp = new HashSet<Professor>();
			if (count < 2) {
				cp.add(profRep.findOne(1L));
				cp.add(profRep.findOne(2L));
				e.setProfessors(cp);
			} else if (count < 4) {
				cp.add(profRep.findOne(2L));
				e.setProfessors(cp);
			} else if (count < 6) {
				cp.add(profRep.findOne(1L));
				cp.add(profRep.findOne(3L));
				e.setProfessors(cp);
			} else if (count < 8) {
				cp.add(profRep.findOne(3L));
				e.setProfessors(cp);
			} else {

			}
			count++;
			editionRep.save(e);
		}
	}

	private void addStudentsEditions(Set<Student> students) {
		for (Edition e : editionRep.findAll()) {
			e.setStudents(students);
			editionRep.save(e);
		}
	}

	private void createEditions() {
		Set<Edition> editions = new HashSet<Edition>();
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(1L), 1, 2015));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(2L), 1, 2015));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(3L), 1, 2015));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(4L), 1, 2015));

		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(5L), 2, 2015));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(6L), 2, 2015));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(7L), 2, 2015));

		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(8L), 1, 2016));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(9L), 1, 2016));
		editions.add(new Edition(degreeRep.findOne(1L), courseRep.findOne(10L), 1, 2016));

		editionRep.save(editions);
	}

	private void createProfessors() {
		Set<Professor> professors = new HashSet<Professor>();
		professors.add(new Professor(accRep.findByUsername("joao").getUsername(),
				accRep.findByUsername("joao").getUsername() + "@fct.unl.pt", accRep.findByUsername("joao")));
		professors.add(new Professor(accRep.findByUsername("manuel").getUsername(),
				accRep.findByUsername("manuel").getUsername() + "@fct.unl.pt", accRep.findByUsername("manuel")));
		professors.add(new Professor(accRep.findByUsername("carla").getUsername(),
				accRep.findByUsername("carla").getUsername() + "@fct.unl.pt", accRep.findByUsername("carla")));
		profRep.save(professors);
	}

	private Set<Student> createStudents() {
		Set<Student> students = new HashSet<Student>();
		students.add(new Student(accRep.findByUsername("andre@fct.unl.pt").getUsername().replace("@fct.unl.pt", ""),
				accRep.findByUsername("andre@fct.unl.pt"), 1000));
		students.add(new Student(accRep.findByUsername("pedro@fct.unl.pt").getUsername().replace("@fct.unl.pt", ""),
				accRep.findByUsername("pedro@fct.unl.pt"), 1001));
		students.add(new Student(accRep.findByUsername("cristiano@fct.unl.pt").getUsername().replace("@fct.unl.pt", ""),
				accRep.findByUsername("cristiano@fct.unl.pt"), 1002));
		studentRep.save(students);

		for (Student s : students) {
			s.setDegree(degreeRep.findOne(1L));
			studentRep.save(s);
		}
		return students;
	}
	
	private void createRoles(){
		Set<Role> roles = new HashSet<Role>();
		roles.add(new Role(AccountRole.STUDENT));
		roles.add(new Role(AccountRole.PROFESSOR));
		roles.add(new Role(AccountRole.ASSISTANT));
		roleRep.save(roles);
	}

	private void createAccounts() throws Exception {
		BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
		Set<Account> accounts = new HashSet<Account>();
		accounts.add(new Account("andre@fct.unl.pt", encoder.encode("andre"), roleRep.findByDescription(AccountRole.STUDENT)));
		accounts.add(new Account("pedro@fct.unl.pt", encoder.encode("pedro"), roleRep.findByDescription(AccountRole.STUDENT)));
		accounts.add(new Account("cristiano@fct.unl.pt", encoder.encode("cristiano"), roleRep.findByDescription(AccountRole.STUDENT)));
		accounts.add(new Account("joao", encoder.encode("joao"), roleRep.findByDescription(AccountRole.PROFESSOR)));
		accounts.add(new Account("manuel", encoder.encode("manuel"), roleRep.findByDescription(AccountRole.PROFESSOR)));
		accounts.add(new Account("carla", encoder.encode("carla"), roleRep.findByDescription(AccountRole.ASSISTANT)));
		accRep.save(accounts);
	}

	private void createCourses() {
		Set<Course> courses = new HashSet<Course>();
		courses.add(new Course("AMI", "Análise Matemática I", "cadeira de matemática", 6));
		courses.add(new Course("AC", "Arquitetura de Computadores", "cadeira de informática", 6));
		courses.add(new Course("ADA", "Algoritmos e desenho de algoritmos", "cadeira de inforática", 6));
		courses.add(new Course("AMII", "Análise Matemática II", "cadeira de matemática", 6));
		courses.add(new Course("POO", "Programação Orientada a Objectos", "cadeira de informática", 6));
		courses.add(new Course("LC", "Lógica Computacional", "cadeira de informática", 6));
		courses.add(new Course("MDS", "Métodos de Desenvolvimento de Software", "cadeira de informática", 6));
		courses.add(new Course("ESf", "Engenharia de Software", "cadeira de informática", 6));
		courses.add(new Course("CIAI", "Conceção e Implementação de Aplicações para Internet", "cadeira de informática",
				6));
		courses.add(new Course("AED", "Algoritmos e estruturas de dados", "cadeira de informática", 6));

		courseRep.save(courses);

		for (Degree d : degreeRep.findAll()) {
			d.setCourses(courses);
			degreeRep.save(d);
		}
	}

	private void createDegrees() {
		Set<Degree> degrees = new HashSet<Degree>();
		degrees.add(new Degree("Mestrado Integrado em Engenharia Informática", ""));
		degrees.add(new Degree("Biologia Celular e Molecular",
				"Mestrados de continuidade: Genética Molecular e Biomedicina, Microbiologia Médica, Biotecnologia, Bioquímica"));
		degrees.add(new Degree("Bioquímica",
				"Mestrados de continuidade: Bioquímica, Biotecnologia, Genética Molecular e Biomedicina, Química Bioorgânica, Tecnologia e Segurança Alimentar"));
		degrees.add(new Degree("Conservação-Restauro",
				"Mestrados de continuidade: Conservação e Restauro, Arte e Ciência do Vidro"));
		degrees.add(
				new Degree("Engenharia Geológica", "Mestrados de continuidade: Engenharia Geológica, Paleontologia"));
		degrees.add(
				new Degree("Matemática", "Mestrados de continuidade: Matemática e Aplicações, Ensino da Matemática"));
		degrees.add(new Degree("Química Aplicada",
				"Mestrados de continuidade: Biotecnologia, Química Bioorgânica Bioquímica, Genética Molecular e Biomedicina, Tecnologia e SegurançaAlimentar"));
		degrees.add(new Degree("Mestrado Integrado em Engenharia do Ambiente", ""));
		degrees.add(new Degree("Mestrado Integrado em Engenharia Civil", ""));
		degrees.add(new Degree("Mestrado Integrado em Engenharia Física", ""));
		degrees.add(new Degree("Mestrado Integrado em Engenharia de Micro e Nanotecnologias", ""));
		degrees.add(new Degree("Mestrado Integrado em Engenharia e Gestão Industrial", ""));

		degreeRep.save(degrees);
	}
}