package cz.frantovo.příklady.reflexe;

import java.lang.reflect.Field;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.Map;

import java.util.Objects;

import java.util.concurrent.ConcurrentHashMap;

import java.util.function.Consumer;

/**

 *

 * @author Ing. František Kučera (frantovo.cz)

 */

public class Reflexe {

	private static final String NÁZEV_PROMĚNNÉ = "proměnná";

	private static final int POČET_OPAKOVÁNÍ = 1000000;

	private static final RoundingMode ZAOKROUHLOVÁNÍ = RoundingMode.UP;

	private static final int PŘESNOST_PROCENT = 2;

	private static final Map<KlíčTřídaPole, Field> známáPole = new ConcurrentHashMap<>();

	private static final Map<Class, Map<String, Field>> známáPole2 = new ConcurrentHashMap<>();

	private static void nastav(Object objekt, String proměnná, Object hodnota) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

		Field f = objekt.getClass().getDeclaredField(proměnná);

		f.setAccessible(true);

		f.set(objekt, hodnota);

		// TODO: můžeme odchytávat výjimky a vyhazovat vlastní výjimku případně běhovou

	}

	private static void nastavOptimalizovaně(Object objekt, String proměnná, Object hodnota) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

		KlíčTřídaPole klíč = new KlíčTřídaPole(objekt.getClass(), proměnná);

		Field f = známáPole.get(klíč);

		if (f == null) {

			f = objekt.getClass().getDeclaredField(proměnná);

			f.setAccessible(true);

			známáPole.put(klíč, f);

		}

		f.set(objekt, hodnota);

		// TODO: můžeme odchytávat výjimky a vyhazovat vlastní výjimku případně běhovou

	}

	private static class KlíčTřídaPole {

		private final Class třída;

		private final String pole;

		public KlíčTřídaPole(Class třída, String pole) {

			this.třída = třída;

			this.pole = pole;

		}

		@Override

		public boolean equals(Object obj) {

			if (obj instanceof KlíčTřídaPole) {

				KlíčTřídaPole druhýKlíč = (KlíčTřídaPole) obj;

				return Objects.equals(třída, druhýKlíč.třída) && Objects.equals(pole, druhýKlíč.pole);

			} else {

				return false;

			}

		}

		@Override

		public int hashCode() {

			return Objects.hash(třída, pole);

		}

	}

	private static void nastavOptimalizovaně2(Object objekt, String proměnná, Object hodnota) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

		Map<String, Field> mapaPolí = známáPole2.get(objekt.getClass());

		if (mapaPolí == null) {

			mapaPolí = new ConcurrentHashMap<>();

			známáPole2.put(objekt.getClass(), mapaPolí);

		}

		Field f = mapaPolí.get(proměnná);

		if (f == null) {

			f = objekt.getClass().getDeclaredField(proměnná);

			f.setAccessible(true);

			mapaPolí.put(proměnná, f);

		}

		f.set(objekt, hodnota);

		// TODO: můžeme odchytávat výjimky a vyhazovat vlastní výjimku případně běhovou

	}

	private static void testSetter(int početOpakování) {

		NějakáTřída t = new NějakáTřída();

		for (int i = 0; i < početOpakování; i++) {

			t.setProměnná(i);

		}

	}

	private static void testPřímýPřístup(int početOpakování) {

		NějakáTřída t = new NějakáTřída();

		for (int i = 0; i < početOpakování; i++) {

			t.veřejnáProměnná = i;

		}

	}

	private static void testReflexe(int početOpakování) {

		NějakáTřída t = new NějakáTřída();

		try {

			for (int i = 0; i < početOpakování; i++) {

				nastav(t, NÁZEV_PROMĚNNÉ, i);

			}

		} catch (Exception e) {

			throw new RuntimeException("test se nezdařil", e);

		}

	}

	private static void testReflexeOptimalizovaná(int početOpakování) {

		NějakáTřída t = new NějakáTřída();

		try {

			for (int i = 0; i < početOpakování; i++) {

				nastavOptimalizovaně(t, NÁZEV_PROMĚNNÉ, i);

			}

		} catch (Exception e) {

			throw new RuntimeException("test se nezdařil", e);

		}

	}

	private static void testReflexeOptimalizovaná2(int početOpakování) {

		NějakáTřída t = new NějakáTřída();

		try {

			for (int i = 0; i < početOpakování; i++) {

				nastavOptimalizovaně2(t, NÁZEV_PROMĚNNÉ, i);

			}

		} catch (Exception e) {

			throw new RuntimeException("test se nezdařil", e);

		}

	}

	private static void testReflexePřipravená(int početOpakování) {

		NějakáTřída t = new NějakáTřída();

		try {

			Field f = t.getClass().getDeclaredField(NÁZEV_PROMĚNNÉ);

			f.setAccessible(true);

			for (int i = 0; i < početOpakování; i++) {

				f.set(t, i);

			}

		} catch (Exception e) {

			throw new RuntimeException("test se nezdařil", e);

		}

	}

	private static String lpad(int početZnaků, Object text) {

		return String.format("%1$" + početZnaků + "s", String.valueOf(text));

	}

	private static BigDecimal spočítejProcenta(long hodnota, long základ) {

		BigDecimal h = BigDecimal.valueOf(hodnota);

		BigDecimal z = BigDecimal.valueOf(základ);

		return h.multiply(BigDecimal.valueOf(100)).divide(z, PŘESNOST_PROCENT, ZAOKROUHLOVÁNÍ);

	}

	private static Long testuj(String názevTestu, int početOpakování, Long časProPorovnání, Consumer<Integer> test) {

		System.out.print("TEST: " + lpad(24, názevTestu) + ": ");

		try {

			long začátek = System.currentTimeMillis();

			test.accept(početOpakování);

			long konec = System.currentTimeMillis();

			long celkovýČas = konec - začátek;

			BigDecimal relativníČas = časProPorovnání == null ? BigDecimal.valueOf(100).setScale(PŘESNOST_PROCENT) : spočítejProcenta(celkovýČas, časProPorovnání);

			System.out.println("početOpakování = " + lpad(12, početOpakování) + " celkovýČas = " + lpad(8, celkovýČas) + " ms relativníČas = " + lpad(8, relativníČas) + " %");

			return celkovýČas;

		} catch (Exception e) {

			System.out.println("došlo k chybě");

			e.printStackTrace();

			return null;

		}

	}

	public static void main(String[] args) {

		long základníČas = testuj("přímý přístup", POČET_OPAKOVÁNÍ, null, Reflexe::testPřímýPřístup);

		testuj("setter", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testSetter);

		testuj("reflexe", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexe);

		testuj("reflexe optimalizovaná 1", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexeOptimalizovaná);

		testuj("reflexe optimalizovaná 2", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexeOptimalizovaná2);

		testuj("reflexe připravená", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexePřipravená);

	}

}