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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

// Skrevet av Dag Langmyhr
// Lett modifisert av Stein Gjessing
// Sist modifisert av SG kl 22:15 den 21. juli
// Aller sist modifisert av DL kl 15:50 den 39. august.


// Oppgave 1
class M?ling {
    M?ling neste = null;
    int antall = 1;
    int tid;
    double dB;
    
    M?ling (int t, double v) {
	tid = t;  dB = v;
    }
}


// Oppgave 2
class MestSt?yANT {
    final int ANT;
    M?ling[] mest;
    private int antHittil = 0;

    // Invariant: Hvis antHittil < ANT: mest[0..antHittil] inneholder alle m?linger
    //            Ellers: mest[0..ANT-1] inneholder de ANT st?rste m?lingene

    MestSt?yANT (int a) {
	ANT = a;  mest = new M?ling[ANT];
    }

    public void settInnANT (M?ling m) {
	if (antHittil < ANT) {
	    mest[antHittil] = m;  ++antHittil;
	    return;
	}

	// Finn minste verdi:
	int minPos = 0;
	for (int i = 1;  i < ANT;  ++i)
	    if (mest[i].dB < mest[minPos].dB)
		minPos = i;

	// Hvis den nye m?lingen er st?rre enn den minste hittil,
	// sett den inn.
	if (m.dB > mest[minPos].dB)
	    mest[minPos] = m;
    }

    public M?ling[] hentUtANT () {
	M?ling[] res = new M?ling[antHittil];
	for (int i = 0;  i < antHittil;  ++i)
	    res[i] = mest[i];
	return res;
    }

    // Hjelperutine til oppgave 9 (iterasjon)
    double sumSt?y () {
	double sum = 0;
	for (int i = 0;  i < antHittil;  ++i)
	    sum += mest[i].dB;
	return sum;
    }
}


// Oppgave 4
class Sted {
    final int ANT;
    M?ling f?rste = null, siste = null;
    MestSt?yANT mestSt?y;
    String navn;
    double maksSt?y = 0;

    Sted (String n, int a) {
	navn = n;  ANT = a;
	mestSt?y = new MestSt?yANT(ANT);
    }

    void settInnM?ling (M?ling inn) {
	mestSt?y.settInnANT(inn);

	if (inn.dB > maksSt?y)
	    maksSt?y = inn.dB;

	if (f?rste == null) {
	    f?rste = inn;  siste = inn;
	    return;
	}

	if (inn.tid >= siste.tid) {
	    siste.neste = inn;
	    siste = inn;
	}
    }
    

    // Oppgave 5
    void sl?Sammen () {
	M?ling m = f?rste;
	while (m != null && m.neste != null) {
	    if (m.tid == m.neste.tid) {
		// Sl? sammen m og m.neste:
		m.dB = 
		    (m.antall*m.dB + m.neste.antall*m.neste.dB) /
		    (m.antall + m.neste.antall);
		m.antall += m.neste.antall;
		m.neste = m.neste.neste;
	    } else {
		m = m.neste;
	    }
	}
    }

    M?ling[] hentUtANT () {
	return mestSt?y.hentUtANT();
    }

    double hentMaksSt?y () {
	return maksSt?y;
    }
}


// Oppgave 7
class Gate {
    String navn;
    StedListe steder;

    Gate (String n) {
	navn = n;  steder = new StedListe();
    }

    // Oppgave 9  (iterasjon)
    M?ling[] finnMestSt?yANT () {
	Sted st?ySted = null;
	double maksSum = 0;	
	for (Sted s: steder) {
	    if (st?ySted == null || s.mestSt?y.sumSt?y() > maksSum) {
		st?ySted = s;  maksSum = s.mestSt?y.sumSt?y();
	    }
	}
	return st?ySted.hentUtANT();
    }

    // Oppgave 12  Start p? rekursjon
    double maksSt?yR() {
	return steder.maksListeR();
    }
}


// Oppgave 7
class StedListe implements Iterable<Sted> {
    StedNode f?rste = null, siste = null;

    class StedNode {
	StedNode neste = null, forrige = null;
	Sted sted;

	// Oppgave 10 Rekursjon
	double maksListeR() {
	    double st?yHer = sted.hentMaksSt?y();
	    if (neste == null)
		return st?yHer;
	    double restMaks = neste.maksListeR();
	    if (st?yHer > restMaks)
		return st?yHer;
	    else
		return restMaks;
	}
    }
    
    // Iterator, oppgave 8
    public Iterator<Sted> iterator () {
	return new StedIterator();
    }

    class StedIterator implements Iterator<Sted> {
	StedNode p = f?rste;

	public boolean hasNext () {
	    return p != null;
	}

	public Sted next () {
	    Sted res = p.sted;
	    p = p.neste;
	    return res;
	}
    }
    
    // Oppgave 11  Start p? rekursjon i listen
    double maksListeR() {
	if (f?rste == null)
	    return 0;
	else
	    return f?rste.maksListeR();
    }
}


// Oppgave 13
class By {
    ArrayList<Gate> gater = new ArrayList<>();
    HashMap<String,Sted> steder = new HashMap<>();

    // Oppgave 14, GUI
    // Metode som kalles fra GUI-vinduet.
    // (Den burde v?rt laget mer robust.)
    void nyRegistrering (String sted, String tid, String dB) throws FeilStedUnntak {
	Sted s = steder.get(sted);
	if (s == null) 
	    throw new FeilStedUnntak(sted);

	int t = Integer.parseInt(tid);
	double d = Double.parseDouble(dB);
	s.settInnM?ling(new M?ling(t, d));
    }
}

class FeilStedUnntak extends Exception {
    FeilStedUnntak (String t) {
	super(t);
    }
}


// Oppgave 14
class GUI {
    By minBy;
    JFrame vindu = null;
    JPanel panel;
    JButton ok;
    JLabel stedLab, tidLab, dBLab;
    JTextField sted, tid, dB;

    GUI (By b) {
	minBy = b;
    }

    class OKHandler implements ActionListener {
	@Override
	    public void actionPerformed (ActionEvent e) {
	    try{
		minBy.nyRegistrering(sted.getText().trim(),
				     tid.getText().trim(), dB.getText().trim());
	    } catch (FeilStedUnntak f) { 
		System.out.println("Ukjent sted: " + f.getMessage()); 
		System.out.println();
	    }
	}
    }

    void lagSt?yVindu () {
	try {
	    UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
	} catch (Exception e) { System.exit(1); }
	vindu = new JFrame("Registrer st?y");
	vindu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

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

	stedLab = new JLabel("Sted:");
	sted = new JTextField("                   ");
	panel.add(stedLab);  panel.add(sted);
	tidLab = new JLabel("Tid:");
	tid = new JTextField("           ");
	panel.add(tidLab);  panel.add(tid);
	dBLab = new JLabel("dB:");
	dB = new JTextField("           ");
	panel.add(dBLab);  panel.add(dB);
	ok = new JButton("OK");
	ok.addActionListener(new OKHandler());
	panel.add(ok);
	vindu.pack();
	sted.setText("                ");
	tid.setText("           ");
	dB.setText("           ");
	vindu.setVisible(true);
    }
}