import java.util.HashMap;
import java.util.Scanner;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


interface Brukerkommunikasjon {
    boolean stillSp?rsm?lOgSjekkSvar ();
}


// Oppgave 2

abstract class Oppgave  /* Oppgave 3: */ implements Comparable<Oppgave> {
    final String tittel, oppgavetekst;
    int antStemmer = 0;

    Oppgave (String tit, String oppg) {
	tittel = tit;  oppgavetekst = oppg;
    }

    // Oppgave 3
    @Override
    public int compareTo (Oppgave o2) {
	return antStemmer - o2.antStemmer;
    }
}

abstract class AutomatrettetOppgave extends Oppgave implements Brukerkommunikasjon {
    AutomatrettetOppgave (String tit, String oppg) {
	super(tit, oppg);
    }
}

class Flervalgsoppgave extends AutomatrettetOppgave {
    final int rettSvar;

    Flervalgsoppgave (String tit, String oppg, int svar) {
	super(tit, oppg);
	rettSvar = svar;
    }

    // Oppgave 10
    JFrame vindu = null;
    JPanel panel = null;
    JLabel oppgaven = null;
    JButton knapp1, knapp2, knapp3;
    Utsatt<Integer> svaroverf?ring = new Utsatt<>();
    
    @Override
    public boolean stillSp?rsm?lOgSjekkSvar () {
	if (vindu == null) {
	    try {
                UIManager.setLookAndFeel(UIManager.
		    getCrossPlatformLookAndFeelClassName());
	    } catch (Exception e) { System.exit(9); }
	    vindu = new JFrame("Oppgave");
	    vindu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

	    panel = new JPanel();
	    vindu.add(panel);

	    oppgaven = new JLabel(oppgavetekst);
	    panel.add(oppgaven);

	    knapp1 = new JButton(" A ");
	    knapp2 = new JButton(" B ");
	    knapp3 = new JButton(" C ");
	    class Svarer implements ActionListener {
		int svar;
		Svarer (int s) { svar = s; }
		
		@Override
		public void actionPerformed (ActionEvent e) {
		    svaroverf?ring.sett(svar);
		    vindu.setVisible(false);
		}
	    }
	    knapp1.addActionListener(new Svarer(1));
	    knapp2.addActionListener(new Svarer(2));
	    knapp3.addActionListener(new Svarer(3));
	    panel.add(knapp1);  panel.add(knapp2);  panel.add(knapp3);

	    vindu.pack();
	    vindu.setLocationRelativeTo(null);
	    vindu.setVisible(true);
	} else {
	    oppgaven.setText(oppgavetekst);
	    vindu.setVisible(true);
	}
	int svar = svaroverf?ring.hent();
	return svar == rettSvar;
    }
}

class Tallsvaroppgave extends AutomatrettetOppgave {
    final int rettSvar;
    
    Tallsvaroppgave (String tit, String oppg, int svar) {
	super(tit, oppg);
	rettSvar = svar;
    }

    // Oppgave 8
    private Scanner tastatur = new Scanner(System.in);

    @Override
    public boolean stillSp?rsm?lOgSjekkSvar () {
	System.out.println("Oppgave: " + oppgavetekst);
	System.out.print("Hva er ditt svar? ");
	int svar = tastatur.nextInt();
	if (svar == rettSvar) {
	    System.out.println("Svaret er rett!");
	    return true;
	} else {
	    System.out.println("Svaret er feil; rett svar er " + rettSvar + ".");
	    return false;
	}
    }
}

class Ordsvaroppgave extends AutomatrettetOppgave {
    final String rettSvar;
    
    Ordsvaroppgave (String tit, String oppg, String svar) {
	super(tit, oppg);
	rettSvar = svar;
    }
}

abstract class ManueltrettetOppgave extends Oppgave {
    ManueltrettetOppgave (String tit, String oppg) {
	super(tit, oppg);
    }
}

class Programmeringsoppgave extends ManueltrettetOppgave {
    Programmeringsoppgave (String tit, String oppg) {
	super(tit, oppg);
    }
}

class Tekstsvaroppgave extends ManueltrettetOppgave {
    Tekstsvaroppgave (String tit, String oppg) {
	super(tit, oppg);
    }
}

// Oppgave 4

class Toppliste<E extends Comparable<E>> {
    final int MAX_ANTALL = 5;
    
    private Node bunn = null;
    private int antall = 0;

    private class Node {
	E elem;
	Node over = null;

	Node (E e) { elem = e; }

	// Oppgave 6
	void sjekkSorteringRekursivt () throws IkkeSortert {
	    if (over == null) return;  // Ferdig!

	    if (elem.compareTo(over.elem) > 0)
		throw new IkkeSortert();
	    over.sjekkSorteringRekursivt();
	}
    }

    // Oppgave 4
    public void settInn (E elem) {
	Node nyNode = new Node(elem);
	
	if (antall == 0) {
	    // Listen er tom:
	    bunn = nyNode;
	} else if (elem.compareTo(bunn.elem) <= 0) {
	    // Det nye elementet skal inn sist:
	    nyNode.over = bunn;  
	    bunn = nyNode;
	} else {
	    // Vi m? lete oss frem til hvor det nye elementet skal inn:
	    Node denne = bunn;
	    while (denne.over != null && elem.compareTo(denne.over.elem) > 0)
		denne = denne.over;
	    // Det nye elementet skal inn mellom denne.over og denne;
	    // koden fungerer selv om denne.over == null.
	    nyNode.over = denne.over;
	    denne.over = nyNode;
	}
	++antall;

	// Fjern overfl?dige elementer:
	while (antall > MAX_ANTALL) {
	    bunn = bunn.over;
	    --antall;
	}
    }

    // Oppgave 7
    // Hjelpemetode: Fjerner et element fra listen, forutsatt at det er der.
    void fjern (E o) {
	// F?rst: finn riktig Node:
	Node denne = bunn, forrige = null;
	
	while (denne != null && denne.elem != o) {
	    forrige = denne;  denne = denne.over;
	}

	// Hvis elementet ikke er i listen, er det ingenting ? gj?re.
	if (denne == null) return;

	if (denne == bunn) {
	    // Noden bunn skal fjernes:
	    bunn = bunn.over;
	} else {
	    // Noden denne (som ikke er bunn) skal fjernes:
	    forrige.over = denne.over;
	}
	--antall;
    }

    // Oppgave 6
    void sjekkSortering () throws IkkeSortert {
	if (bunn != null)
	    bunn.sjekkSorteringRekursivt();
    }
}

// Oppgave 5

class Oppgavesamling {
    HashMap<String,Oppgave> alleOppgaver = new HashMap<>();
    Toppliste<Oppgave> topp5 = new Toppliste<>();

    void registrerOppgave (Oppgave o) {
	alleOppgaver.put(o.tittel, o);
	topp5.settInn(o);
    }

    int antallAutomatiske () {
	int ant = 0;
	for (Oppgave ox: alleOppgaver.values()) {
	    if (ox instanceof AutomatrettetOppgave)
		++ant;
	}
	return ant;
    }

    // Oppgave 7
    void giStemme (Oppgave o) {
	++o.antStemmer;
	topp5.fjern(o);
	topp5.settInn(o);
    }
}

// Oppgave 6

class IkkeSortert extends Exception { }

// Oppgave 9

class Utsatt<E> {
    E data = null;
    Lock l?s = new ReentrantLock();
    Condition ventP?Data = l?s.newCondition();

    void sett (E e) {
	l?s.lock();
	try {
	    data = e;
	    ventP?Data.signalAll();
	} finally {
	    l?s.unlock();
	}
    }

    E hent () {
	l?s.lock();
	try {
	    while (data == null)
		ventP?Data.await();
	    E res = data;
	    data = null;
	    return res;
	} catch (InterruptedException e) {
	    return null;
	} finally {
	    l?s.unlock();
	}
    }
}