// Apply the java plugin to add support for Java
apply plugin: 'java'
apply plugin: 'org.flywaydb.flyway'

// In this section you declare where to find the dependencies of your project
repositories {
    // Use 'jcenter' for resolving your dependencies.
    // You can declare any Maven/Ivy/file repository here.
    jcenter()
}

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "org.flywaydb:flyway-gradle-plugin:4.0.3"
    
  }
}

flyway {
  url = 'jdbc:postgresql://localhost:5432/game_db'
  user = 'postgres'
  password = 'postgres'
}

def spring_version = '5.0.1.RELEASE'

// In this section you declare the dependencies for your production and test code
dependencies {
    // The production code uses the SLF4J logging API at compile time
   	compile group: 'org.slf4j', name: 'slf4j-log4j12', version: '1.7.25'
    
    compile group: 'org.springframework', name: 'spring-core', 	  version: spring_version
    compile group: 'org.springframework', name: 'spring-context', version: spring_version
    compile group: 'org.springframework', name: 'spring-jdbc', 	  version: spring_version
    compile group: 'org.springframework', name: 'spring-tx', 	  version: spring_version

    compile group: 'io.javaslang', name: 'javaslang', 	  version: '2.0.5'    
    compile group: 'com.github.menacher', name: 'nadron', version: '0.7'    
    compile group: 'org.json', name: 'json', version: '20160810'
        
    compile 'com.mchange:c3p0:0.9.5.2'
  	compile 'org.flywaydb:flyway-core:4.0.3'
  	
  	runtime("org.postgresql:postgresql:9.4.1212")
    testCompile 'junit:junit:4.12'
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

	<import resource="classpath:/nadron/beans/server-beans.xml"></import>
	<context:annotation-config />

	<bean id="webSocketLoginHandler" class="com.bbl.app.handlers.GameLoginHandler">
		<property name="lookupService" ref="lookupService" />
		<property name="idGeneratorService" ref="simpleUniqueIdGenerator" />
		<property name="reconnectRegistry" ref="reconnectSessionRegistry" />
		<property name="jackson" ref="jackson" />
	</bean>
</beans>

public class GameLoginHandler extends WebSocketLoginHandler {

	private static final Logger LOG = LoggerFactory.getLogger(GameLoginHandler.class);
	
	@Override
	public void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame frame) throws Exception {
		Channel channel = ctx.channel();
		String data = frame.text();
		Event event = getJackson().readValue(data, DefaultEvent.class);
		int type = event.getType();
		if (Events.LOG_IN == type) {
			LOG.trace("Login attempt from {}", channel.remoteAddress());
			@SuppressWarnings("unchecked")
			Player player = lookupPlayer((LinkedHashMap<String, Object>) event.getSource());
			handleLogin(player, channel);
			if(null != player)
				handleGameRoomJoin(player, channel, MyGame.LOBBY_NAME);
		} else if (type == Events.RECONNECT) {
			LOG.debug("Reconnect attempt from {}", channel.remoteAddress());
			PlayerSession playerSession = lookupSession((String) event.getSource());
			handleReconnect(playerSession, channel);
		} else {
			LOG.error("Invalid event {} sent from remote address {}. " + "Going to close channel {}",
					new Object[] { event.getType(), channel.remoteAddress(), channel });
			closeChannelWithLoginFailure(channel);
		}
	}

	public Player lookupPlayer(Map<String, Object> source) throws Exception {
		String user = String.valueOf(source.get("user"));
		String vkUid = String.valueOf(source.get("uid"));
		String vkKey = String.valueOf(source.get("key"));
		
		GameCredentials credentials = new GameCredentials(user, vkUid, vkKey);		
		credentials.setPicture(String.valueOf(source.get("picture")));
		credentials.setSex(Integer.valueOf(String.valueOf(source.get("sex"))));
		credentials.setHash(String.valueOf(source.get("hash")));	
		Player player = getLookupService().playerLookup(credentials);
		if (null == player) {
			LOG.error("Invalid credentials provided by user: {}", credentials);
		}
		return player;
	}
}

public class GameLookupService extends SimpleLookupService{
	
	@Autowired
	private MyGame myGame;	
	@Autowired
	private GameDao gameDao;	
	@Autowired
	private LobbyRoom lobby;	
	@Autowired
	private GameManager gameManager;
	
	@Override
	public Player playerLookup(Credentials loginDetail) {
		Optional<GamePlayer> player = Optional.empty();
		GameCredentials credentials = (GameCredentials) loginDetail;
		
		String authKey = myGame.getAppId() + '_' + credentials.getVkUid() + '_' + myGame.getAppSecret();
		try {
			// Проверка ключа
			if (Objects.equals(credentials.getVkKey().toUpperCase(), MD5.encode(authKey))) {
				player = gameDao.fetchPlayerByVk(credentials.getVkUid(), credentials.getVkKey());
				if(!player.isPresent()){
					// Создаем аккаунт
					player = Optional.of(cratePlayer((GameCredentials) loginDetail));
					gameDao.createPlayer(player.get());
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
			
		return player.orElse(null);
	}

	private GamePlayer cratePlayer(GameCredentials loginDetail) {
		GamePlayer player = new GamePlayer();
		player.setVkUid(loginDetail.getVkUid());
		player.setVkKey(loginDetail.getVkKey());
		player.setName(loginDetail.getUsername());
		player.setPicture(loginDetail.getPicture());
		player.setSex(loginDetail.getSex());
		player.setRef(loginDetail.getHash());
		player.setMail("");
		player.setCreated(LocalDateTime.now());		
		player.setRating(0);
		player.setMoney(10);
		player.setClanId(0L);
		return player;
	}

	@Override
	public GameRoom gameRoomLookup(Object gameContextKey) {
		return lobby;
	}
}

CREATE TABLE public.players
(
  id 		bigserial NOT NULL,
  mail      character varying,
  name	    character varying,
  password  character varying,
  vk_uid    character varying,
  vk_key    character varying,
  ref		character varying,
  sex		integer NOT NULL,
  money		integer NOT NULL,
  rating	integer NOT NULL,
  clan_id   bigint NOT NULL,
  created   timestamp without time zone NOT NULL,
  CONSTRAINT players_pkey PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);

CREATE EXTENSION IF NOT EXISTS citext;
ALTER TABLE players ALTER COLUMN vk_uid TYPE citext; 

@SuppressWarnings("serial")
public class CustomEvent extends DefaultEvent {

	private EventData source;

	@Override
	public EventData getSource() {
		return source;
	}

	public void setSource(EventData source) {
		this.source = source;
	}

	public static NetworkEvent networkEvent(GameCmd cmd, Object data) throws JSONException {
		EventData source = new EventData();
		source.setCmd(cmd.getCode());
		source.setData(data);
		return Events.networkEvent(source);
	}
}

public class LobbyRoom extends GameRoomSession {

	private static final Logger LOG = LoggerFactory.getLogger(LobbyRoom.class);

	private RoomFactory roomFactory;

	public LobbyRoom(GameRoomSessionBuilder gameRoomSessionBuilder) {
		super(gameRoomSessionBuilder);
		this.addHandler(new LobbySessionHandler(this));
		getStateManager().setState(new LobbyState());
	}

	@Override
	public void onLogin(PlayerSession playerSession) {
		LOG.info("sessions size: " + getSessions().size());
		playerSession.addHandler(new PlayerSessionHandler(playerSession));
		
		try {
			playerSession.onEvent(CustomEvent.networkEvent(GameCmd.PLAYER_DATA, playerSession.getPlayer()));
		} catch (JSONException e) {
			LOG.error(e.getMessage());
			e.printStackTrace();
		}
	}

	public RoomFactory getRoomFactory() {
		return roomFactory;
	}

	public void setRoomFactory(RoomFactory roomFactory) {
		this.roomFactory = roomFactory;
	}
}

@Override
public void onEvent(Event event) {
	CustomEvent customEvent = (CustomEvent) event;
	GameCmd cmd = GameCmd.CommandsEnum.fromInt(customEvent.getSource().getCmd());
	try {
		switch (cmd) {
		case CREATE_GAME:
			createRoom(customEvent);
			break;
		case GET_OPEN_ROOMS:
			broadcastRoomList(customEvent);
			break;
		case JOIN_ROOM:
			connectToRoom(customEvent);
			break;
		default:
			LOG.error("Received invalid command {}", cmd);
			throw new InvalidCommandException("Received invalid command" + cmd);
		}
	} catch (InvalidCommandException e) {
		e.printStackTrace();
		LOG.error("{}", e);
	}
}

public class GameWebsocketProtocol extends AbstractNettyProtocol {

	private static final Logger LOG = LoggerFactory.getLogger(WebSocketProtocol.class);

	private static final String TEXT_WEBSOCKET_DECODER = "textWebsocketDecoder";
	private static final String TEXT_WEBSOCKET_ENCODER = "textWebsocketEncoder";
	private static final String EVENT_HANDLER = "eventHandler";

	private TextWebsocketDecoder textWebsocketDecoder;
	private TextWebsocketEncoder textWebsocketEncoder;

	public GameWebsocketProtocol() {
		super("GAME_WEB_SOCKET_PROTOCOL");
	}

	@Override
	public void applyProtocol(PlayerSession playerSession, boolean clearExistingProtocolHandlers) {

		applyProtocol(playerSession);

		if (clearExistingProtocolHandlers) {
			ChannelPipeline pipeline = NettyUtils.getPipeLineOfConnection(playerSession);
			if (pipeline.get(LoginProtocol.LOGIN_HANDLER_NAME) != null)
				pipeline.remove(LoginProtocol.LOGIN_HANDLER_NAME);
			if (pipeline.get(AbstractNettyProtocol.IDLE_STATE_CHECK_HANDLER) != null)
				pipeline.remove(AbstractNettyProtocol.IDLE_STATE_CHECK_HANDLER);
		}
	}

	@Override
	public void applyProtocol(PlayerSession playerSession) {

		LOG.trace("Going to apply {} on session: {}", getProtocolName(), playerSession);
		ChannelPipeline pipeline = NettyUtils.getPipeLineOfConnection(playerSession);
		if (pipeline.get(TEXT_WEBSOCKET_DECODER) == null)
			pipeline.addLast(TEXT_WEBSOCKET_DECODER, textWebsocketDecoder);
		if (pipeline.get(EVENT_HANDLER) == null)
			pipeline.addLast(EVENT_HANDLER, new DefaultToServerHandler(playerSession));
		if (pipeline.get(TEXT_WEBSOCKET_ENCODER) == null)
			pipeline.addLast(TEXT_WEBSOCKET_ENCODER, textWebsocketEncoder);
	}

	public TextWebsocketDecoder getTextWebsocketDecoder() {
		return textWebsocketDecoder;
	}

	public void setTextWebsocketDecoder(TextWebsocketDecoder textWebsocketDecoder) {
		this.textWebsocketDecoder = textWebsocketDecoder;
	}

	public TextWebsocketEncoder getTextWebsocketEncoder() {
		return textWebsocketEncoder;
	}

	public void setTextWebsocketEncoder(TextWebsocketEncoder textWebsocketEncoder) {
		this.textWebsocketEncoder = textWebsocketEncoder;
	}
}