import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;

public class BrainMod extends JPanel implements ActionListener {
	private static final long serialVersionUID = 1L;
	private static JTextArea textin;

	final static int Nexc = 12; // количество возбуждающих нейронов
	final static int Ninh = 3; // Количество тормозных нейронов
	final static int Nneur = Nexc + Ninh;
	final static int Ncon = (int) (Nneur * Nneur * 0.1f); // Количество связей
	// 0.1
	static float[] Vms = new float[Nneur]; // Мембранные потенциалы
	static float[] Ums = new float[Nneur]; // вспомогательные переменные модели

	static float V0 = -60.0f; // начальное значение для мембранного потенциала
	static float U0 = 0.0f; // начальное значение для вспомогательной переменной
	static int[] pre_conns = new int[Ncon]; // Индексы пресинаптических нейронов
	static int[] post_conns = new int[Ncon];// Индексы постсинаптических
											// нейронов
	static float[] weights = new float[Ncon]; // Веса связей
	static float psc_excxpire_time = 4.0f; // характерное вермя спадания
	// постсинаптического тока, мс
	static float minWeight = 50.0f; // веса, размерность пкА
	static float maxWeight = 100.0f;

	// Параметры нейрона
	static float Iex_max = 40.0f; // максимальный приложенный к нейрону ток 50
									// пкА
	static float a = 0.02f;
	static float b = 0.5f;
	static float c = -40.0f; // значение мембранного потенциала до которого он
	// сбрасываеться после спайка
	static float d = 100.0f;
	static float k = 0.5f;
	static float Vr = -60.0f;
	static float Vt = -45.0f;
	static float Vpeak = 35.0f; // максимальное значение мембранного потенциала,
								// при
	// котором происходит сброс до значения с
	static float Cm = 50.0f; // электрическая ёмкость нейрона, размерность пкФ
	static float[] y = new float[Ncon];
	static float[] Iex = new float[Nneur]; // Внешний постоянный ток приложенный
											// к
	// нейрону
	static float[] Isyn = new float[Nneur]; // Синаптический ток на каждый
											// нейрон

	final static float h = .5f; // временной шаг интегрирования
	int j;

	static int[] GrNeur = new int[Nneur];
	static Map<Integer, HashSet<Integer>> Map1Neuron;
	static Map<Integer, Integer> Map1NeuronDr;
	static String[] StrN = new String[Ncon];
	static HashSet<Integer> intcsp = new HashSet<Integer>();

	public void paintComponent(Graphics g) {
		// Инициализируем генератор
		int min = 50;
		int max = 600;
		Random rnd = new Random(System.currentTimeMillis());
		int numberx;
		int numbery;
		// Получаем случайное число в диапазоне от min до max (включительно)
		// Рисуем нейроны в количестве Nneur
		for (int i = 0; i < Nneur; i++) {
			numberx = min + rnd.nextInt(max - min + 1);
			numbery = min + rnd.nextInt(max - min + 1);
			g.setColor(Color.RED);
			HashSet<Integer> intN = new HashSet<Integer>();
			intN.add(numberx);
			intN.add(numbery);
			Map1Neuron.put(i, intN);
			g.fillOval(numberx, numbery, 20, 20);
		}

		// Рисуем связи нейронов - пост и пресинаптического.
		for (int con_idx = 0; con_idx < Ncon; con_idx++) {
			String[] arrayMessage = StrN[con_idx].split(" ");

			int icpre = Integer.parseInt(arrayMessage[0]);
			int ibpost = Integer.parseInt(arrayMessage[1]);

			int drstx = 0;
			int drsty = 0;

			int drctx = 0;
			int drcty = 0;

			for (Map.Entry<Integer, HashSet<Integer>> entry : Map1Neuron
					.entrySet()) {
				int key = entry.getKey();
				HashSet<Integer> value = entry.getValue();

				int[] ints = new int[value.size()];
				int index = 0;
				for (Integer i : value) {
					ints[index++] = i;
				}

				if (icpre == key) {
					drstx = ints[0];
					drsty = ints[1];
					break;
				}

			}
			for (Map.Entry<Integer, HashSet<Integer>> entry : Map1Neuron
					.entrySet()) {
				int key = entry.getKey();
				HashSet<Integer> value = entry.getValue();

				int[] ints = new int[value.size()];
				int index = 0;
				for (Integer i : value) {
					ints[index++] = i;
				}
				if (ibpost == key) {
					drctx = ints[0];
					drcty = ints[1];
					break;
				}
			}
			g.setColor(Color.GREEN);
			g.drawLine(drstx, drsty, drctx, drcty);
		}

		// Модуль рисования возбуждения отдельного нейрона.
		for (Integer i : intcsp) {
			for (Map.Entry<Integer, HashSet<Integer>> entry : Map1Neuron
					.entrySet()) {
				int key = entry.getKey();
				HashSet<Integer> value = entry.getValue();

				int[] ints = new int[value.size()];
				int index = 0;
				for (Integer l : value) {
					ints[index++] = l;
				}
				if (i == key) {
					try {
						g.setColor(Color.ORANGE);
						g.fillOval(ints[0], ints[1], 20, 20);
						Thread.sleep(1000);
						intcsp.remove(i);
						break;
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}

		// this.repaint();
	}

	public static void main(String args[]) {
		Map1Neuron = new HashMap<Integer, HashSet<Integer>>();
		Map1NeuronDr = new HashMap<Integer, Integer>();
		init_connections();
		JFrame frame = new JFrame("BrainNeuro Expert2.0");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		BrainMod panel = new BrainMod();
		textin = new JTextArea(2, 50);
		textin.setLineWrap(true);
		panel.add(textin);
		JButton button = new JButton("Анализ");
		ActionListener actionListener = new BrainMod();
		button.addActionListener(actionListener);
		panel.add(button);
		frame.add(panel);
		frame.setSize(900, 750);
		frame.setLocationRelativeTo(frame);
		frame.setVisible(true);
	}

	private static void init_connections() {
		for (int con_idx = 0; con_idx < Ncon; con_idx++) {
			// случайно выбираем постсипантические и пресинаптические нейроны
			int pre = (int) (Math.random() * Nneur);
			int post = (int) (Math.random() * Nneur);
			pre_conns[con_idx] = pre;
			post_conns[con_idx] = post;
			StrN[con_idx] = pre + " " + post;
			weights[con_idx] = (float) ((Math.random() * ((int) (maxWeight - minWeight) * 10)) / 10.0f + minWeight);
			if (pre >= Nexc) {
				// если пресинаптический нейрон тормозный то вес связи идет со
				// знаком минус
				weights[con_idx] = -weights[con_idx];
			}
			y[con_idx] = 0.0f;
		}
	}

	private static float izhik_Um(int neuron) {
		return a * (b * (Vms[neuron] - Vr) - Ums[neuron]);
	}

	private static float izhik_Vm(int neuron) {
		return (k * (Vms[neuron] - Vr) * (Vms[neuron] - Vt) - Ums[neuron]
				+ Iex[neuron] + Isyn[neuron])
				/ Cm;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		j = 0;
		String s = textin.getText().trim();
		try {
			j = Integer.parseInt(s); // Номер нейрона,который мы активируем.
			intcsp.add(j);
			Iex[j] = (float) ((Math.random() * (int) (Iex_max * 10)) / 10.0f);
			Isyn[j] = 0.0f;
			Vms[j] = V0;
			Ums[j] = U0;
			System.out.println("#neur -  " + j + " - "
					+ (float) ((Math.random() * (int) (Iex_max * 10)) / 10.0f)
					+ " V0 " + V0 + " U0 " + U0);

			float expire_coeff = (float) Math.exp(-h / psc_excxpire_time);

			for (int neur = 0; neur < Nneur; neur++) {
				Vms[neur] = Vms[neur] + h * izhik_Vm(neur);
				Ums[neur] = Ums[neur] + h * izhik_Um(neur);
				Isyn[neur] = 0.0f;
				if (Vms[neur] > Vpeak) {
					intcsp.add(neur); // Добавляем номер нейрона, который
										// "активизировался"
					Vms[neur] = c;
					Ums[neur] = Ums[neur] + d;
				}
			}
			for (int con = 0; con < Ncon; con++) {
				y[con] = y[con] * expire_coeff;

				if (Vms[pre_conns[con]] > Vpeak) {
					y[con] = 1.0f;
				}
				Isyn[post_conns[con]] += y[con] * weights[con];
			}
		} catch (NumberFormatException ex) {
			System.out.println("Ошибка ввода!");
			System.exit(0);
		}
	}
}