package com.jacada.is.as.dao;

import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.net.ssl.SSLSocketFactory;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.authentication.UserCredentials;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;

import com.google.common.collect.Lists;
import com.jacada.is.model.bean.tenant.Tenant;
import com.jacada.is.model.resources.exceptions.CisException;
import com.jacada.is.model.resources.exceptions.FailureCode;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.MongoException;
import com.mongodb.ReadPreference;
import com.mongodb.ServerAddress;
import com.mongodb.WriteResult;
import com.mongodb.util.JSON;
import com.mongodb.util.JSONParseException;

public class MongoConnectionManager extends AbstractConnectionManager {

	private final static Logger log = LoggerFactory.getLogger(MongoConnectionManager.class);

	public final static String SYSTEM_TENANT_ID = "system";
	public static final int MONGO_DEFAULT_PORT = 27017;
	private static final String IP_DELIMITER = ",";
	final String ADMIN_DB_NAME = "admin";

	MongoClient mongoClient;

	MongoTemplate mongoTemplate;

	GridFsTemplate gridFsTemplate;

	@Autowired
	private ITenantDao tenantDao;

	private Map<String, MongoConnection> mongoConnections = new ConcurrentHashMap<>();

	private String systemTenantHost = "localhost";

	private String systemTenantHostPort = "27017";

	private String systemTenantHostUsername;

	private String systemTenantHostPassword;

	// Setting from properties and xml
	@Value("${mongo.ssl.mode}")
	private String mongoSslMode;

	@Value("${mongo.ldap.mode}")
	private String mongoLdapMode;

	@Value("${mongo.host}")
	private String mongoHost;

	@Value("${mongo.systemhost}")
	private String mongoSystemHost;

	@Value("${mongo.port}")
	private int mongoPort;

	@Value("${mongo.database}")
	private String mongoDataBase;

	@Value("${mongo.username}")
	private String username;

	@Value("${mongo.password}")
	private String password;

	@Value("${mongo.readSecondary}")
	private boolean readSecondary = false;

	@Value("${mongo.connections.per.host}")
	private int connectionsPerHost;

	@Value("${mongo.threads.allowed.to.block.for.connection.multiplier}")
	private int threadsAllowedToBlockForConnectionMultiplier;

	@Value("${mongo.connect.timeout}")
	private int connectionTimeout;

	@Value("${mongo.auto.connect.retry}")
	private boolean autoConnectRetry;

	@Value("${mongo.max.wait.time}")
	private int maxWaitTime;

	@Value("${mongo.write.number}")
	private int writeNumber;

	@Value("${mongo.socket.timeout}")
	private int socketTimeout;

	@Value("${mongo.write.fsync}")
	private boolean writeFsync;


	@Value("${reports.mongo.tags:default}")
	private String MONGO_TAGS_PHRASE;

	private Object mongoTagsObject;

	@PreDestroy
	public void destroy() {
		log.debug("\n Destroy all connections START");
		for (MongoConnection mongoConnection : mongoConnections.values()) {
			log.debug("    Destroy: {}", mongoConnection.mongoTemplate.getDb().getName());
			log.debug("    Before: connector is open: {}", mongoConnection.mongoTemplate.getDb().getMongo()
					.getConnector().isOpen());
			mongoConnection.mongoTemplate.getDb().getMongo().close();
			mongoConnection.mongoTemplate.getDb().getMongo().getConnector().close();
			log.debug("    After: connector is open: {}", mongoConnection.mongoTemplate.getDb().getMongo()
					.getConnector().isOpen());
		}
		log.debug("Destroy all connections END \n");
	}

	@PostConstruct
	public void init() throws UnknownHostException {
		log.trace(" \n Account connections initialization START");
		mongoClient = new MongoClient(extractMongoHosts(), getMongoCredentials(), buildMongoClientOps());
		MongoDbFactory dbFactory = new SimpleMongoDbFactory(mongoClient, mongoDataBase);
		mongoTemplate = new MongoTemplate(dbFactory);
		gridFsTemplate = new GridFsTemplate(dbFactory, mongoTemplate.getConverter());

		MongoConnection connection = new MongoConnection();
		connection.mongoTemplate = mongoTemplate;
		connection.gridFsTemplate = gridFsTemplate;

		mongoConnections.put(SYSTEM_TENANT_ID, connection);

		// probably don't need this
		// deviceMetadataCollectionInitializer.init(SYSTEM_TENANT_ID);



		List<Tenant> tenants = tenantDao.list();
		for (Tenant tenant : tenants) {
			createDatabase(	tenant.getId(),
							getSystemTenantHost(),
							getSystemTenantHostPort(),
							getSystemTenantHostUsername(),
							getSystemTenantHostPassword());
		}

		// createDatabaseForTests();
		log.trace("Account connections initialization END");
	}

	/**
	 *
	 * @param tenantId
	 * @return
	 * @throws CisException
	 */
	public MongoTemplate getConnection(String tenantId) throws CisException {
		MongoConnection mongoConnection = getMongoConnection(tenantId);
		return mongoConnection.mongoTemplate;
	}

	public GridFsTemplate getGridFsTemplate(String tenantId) throws CisException {
		MongoConnection mongoConnection = getMongoConnection(tenantId);
		return mongoConnection.gridFsTemplate;
	}

	private MongoConnection getMongoConnection(String tenantId) {
		if (!mongoConnections.containsKey(tenantId)) {
			Tenant tenant = tenantDao.get(tenantId);
			if (tenant == null) {
				log.error("There are no connections by this tenant Id: {}", tenantId);
				throw new CisException(	"There are no connections by this tenant Id:" + tenantId,
										FailureCode.ERR_ILLEGAL_STATE);
			}

			createDatabase(	tenantId,
							getSystemTenantHost(),
							getSystemTenantHostPort(),
							getSystemTenantHostUsername(),
							getSystemTenantHostPassword());
		}
		MongoConnection mongoConnection = mongoConnections.get(tenantId);
		return mongoConnection;
	}

	public void createDatabase(String tenantId) {
		createDatabase(	tenantId,
						getSystemTenantHost(),
						getSystemTenantHostPort(),
						getSystemTenantHostUsername(),
						getSystemTenantHostPassword());
	}

	private void createUserInDB(String tenantId, String username, String password) {
		final String ADMIN_DB_NAME = "admin";
		MongoCredential creds = MongoCredential
				.createMongoCRCredential(username, ADMIN_DB_NAME, password.toCharArray());
		MongoClient adminMongoClient = new MongoClient(mongoClient.getAllAddress(), Arrays.asList(creds));
		DB adminDb = adminMongoClient.getDB(tenantId);

		DBCollection usersCollection = adminDb.getCollection("system.users");
		DBObject existingUser = usersCollection.findOne(new BasicDBObject("user", username));
		if (existingUser == null) {
			WriteResult res = adminDb.addUser(username, password.toCharArray());
			if (StringUtils.isNotBlank(res.getError())) {
				log.error("Cannot create user for new DB. Reason: " + res.getError());
			}
		}
	}

	public void createDatabase(String tenantId, String hosts, String port, String username, String password) {
		log.trace("Create connection to the database: {}", tenantId);

		if (readSecondary) { //used for reports war
			if(!MONGO_TAGS_PHRASE.equals("default")){
				try {
					mongoTagsObject = JSON.parse(MONGO_TAGS_PHRASE);
					mongoClient.setReadPreference(ReadPreference.secondaryPreferred((DBObject)mongoTagsObject, new BasicDBObject()));
				} 	catch (JSONParseException exception){
					log.error("could not parse the following mongo tags phrase: " + MONGO_TAGS_PHRASE + " for the following reason: " + exception.getMessage());
					mongoClient.setReadPreference(ReadPreference.secondaryPreferred());
				}
			} else {
				mongoClient.setReadPreference(ReadPreference.secondaryPreferred());
			}
		}

		MongoTemplate mongoTemplate;
		GridFsTemplate gridFsTemplate;
		if (StringUtils.isNotBlank(username)) {
			createUserInDB(tenantId, username, password);
			UserCredentials credentials = new UserCredentials(username, password);
			mongoTemplate = new MongoTemplate(mongoClient, tenantId, credentials);
			MongoDbFactory dbFactory = new SimpleMongoDbFactory(mongoClient, tenantId, credentials);
			gridFsTemplate = new GridFsTemplate(dbFactory, mongoTemplate.getConverter());
		} else {
			mongoTemplate = new MongoTemplate(mongoClient, tenantId);
			MongoDbFactory dbFactory = new SimpleMongoDbFactory(mongoClient, tenantId);
			gridFsTemplate = new GridFsTemplate(dbFactory, mongoTemplate.getConverter());
		}

		log.trace("Existing collections of database {}:", tenantId);
		for (String collectionName : mongoTemplate.getCollectionNames()) {
			log.trace("	{}", collectionName);
		}

		MongoConnection connection = new MongoConnection();
		connection.mongoTemplate = mongoTemplate;
		connection.gridFsTemplate = gridFsTemplate;
		mongoConnections.put(tenantId, connection);

		log.trace("Connection was added succesfully");
	}

	public void deleteDatabase(String name) {
		// TenantConnectionBean tenantConnectionBean =
		// cachedMongoConnectionStorage.getValue(name);
		MongoConnection mongoConnection = mongoConnections.get(name);
		MongoTemplate template = mongoConnection.mongoTemplate;
		try {
			template.getDb().dropDatabase();
			mongoConnections.remove(name);
		} catch (MongoException e) {
			log.error("Database removing error! DB:" + name, e);
			return;
		}
	}

	public void poll() {
		MongoConnection mongoConnection = mongoConnections.get(SYSTEM_TENANT_ID);
		MongoTemplate template = mongoConnection.mongoTemplate;

		try {
			template.getDb().getStats();
		} catch (Exception e) {
			log.error("Database polling failed", e);
			throw e;
		}
	}

	private static class MongoConnection {

		MongoTemplate mongoTemplate;
		GridFsTemplate gridFsTemplate;
	}

	public void putTenantToMongoConnections(String tenantId) {
		MongoConnection connection = new MongoConnection();
		connection.mongoTemplate = mongoTemplate;
		connection.gridFsTemplate = gridFsTemplate;
		mongoConnections.put(tenantId, connection);
	}

	public String getSystemTenantHost() {
		return systemTenantHost;
	}

	public void setSystemTenantHost(String systemTenantHost) {
		this.systemTenantHost = systemTenantHost;
	}

	public String getSystemTenantHostPort() {
		return systemTenantHostPort;
	}

	public void setSystemTenantHostPort(String systemTenantHostPort) {
		this.systemTenantHostPort = systemTenantHostPort;
	}

	public String getSystemTenantHostUsername() {
		return systemTenantHostUsername;
	}

	public void setSystemTenantHostUsername(String systemTenantHostUsername) {
		this.systemTenantHostUsername = systemTenantHostUsername;
	}

	public String getSystemTenantHostPassword() {
		return systemTenantHostPassword;
	}

	public void setSystemTenantHostPassword(String systemTenantHostPassword) {
		this.systemTenantHostPassword = systemTenantHostPassword;
	}

//	mongo.write.number=1
//	mongo.write.fsync=false
	private MongoClientOptions buildMongoClientOps(){
		MongoClientOptions clientOptions = MongoClientOptions.builder().connectionsPerHost(connectionsPerHost).connectTimeout(connectionTimeout).
		maxWaitTime(maxWaitTime).socketTimeout(socketTimeout).
		threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier).build();

		if(Boolean.valueOf(mongoSslMode)){
			clientOptions.builder().socketFactory(SSLSocketFactory.getDefault()).build(); //add ssl support
		}

		return clientOptions;
	}

	private List<ServerAddress> extractMongoHosts() throws UnknownHostException{
		List<ServerAddress> serverAddresses = Lists.newArrayList();
		String[] hostArr = mongoHost.split(IP_DELIMITER);

		for (String host : hostArr) {
			String[] split = host.split(":");
			ServerAddress addr = new ServerAddress(host, Integer.valueOf(split[1]));
			serverAddresses.add(addr);
		}

		return serverAddresses;
	}

	private List<MongoCredential> getMongoCredentials(){
		List<MongoCredential> credentials = Lists.newArrayList();

		if(StringUtils.isNotBlank(username)){
			if(Boolean.valueOf(mongoLdapMode)){
				credentials.add(MongoCredential.createPlainCredential("mongoroot", "$external", "Jacada2014".toCharArray()).withMechanismProperty("digestPassword", false));
			} else {
				credentials.add(MongoCredential.createMongoCRCredential(username, mongoDataBase, password.toCharArray()));
			}
		}

		return credentials;
	}
}