import com.example.model.MongoAuthentication;
import com.example.model.UsernamePasswordMongoAuthentication;
import com.example.tenant.MongoConnectionCache;
import com.mongodb.DB;
import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.mongodb.core.MongoDbUtils;
import org.springframework.security.crypto.encrypt.TextEncryptor;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.web.context.annotation.ApplicationScope;

import java.util.Collections;
import javax.validation.constraints.NotNull;

/**
 * Caches initialized views of logical databases in a MongoDB cluster for faster access.
 */
@Component
@ApplicationScope
class CachedMongoConnector implements MongoConnector {

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

	private final TextEncryptor encryptor;
	private final MongoConnectionCache cache;

	@Autowired
	CachedMongoConnector(@Qualifier("mongoTextEncryptor") TextEncryptor encryptor, MongoConnectionCache cache) {
		this.encryptor = encryptor;
		this.cache = cache;
	}

	@Override
	public DB connect(@NotNull MongoConnectionConfig connectionConfig, @NotNull String dbName) {
		Assert.notNull(connectionConfig, "Mongo connection configuration must be specified");
		Assert.hasLength(connectionConfig.getHost(), "Mongo host must be specified");
		Assert.hasLength(dbName, "Mongo database to connect to must be specified");
		String configDbName = connectionConfig.getDbName();
		Assert.isTrue(
				dbName.equals(configDbName),
				String.format("Invalid Mongo database to connect to specified: \"%s\" vs. \"%s\"", dbName, configDbName)
		);

		Mongo mongoConnection = cache.get(connectionConfig, config -> {
			Mongo newlyCreatedMongo = initMongoConnection(config);
			LOG.debug("Initialized connection {}", newlyCreatedMongo);
			return newlyCreatedMongo;
		});

		return MongoDbUtils.getDB(mongoConnection, configDbName);
	}

	private Mongo initMongoConnection(MongoConnectionConfig mongoConfig) {
		MongoAuthentication mongoAuth = mongoConfig.getAuth();
		switch (mongoAuth.getType()) {
			case NONE:
				return initUnauthenticatedMongoConnection(mongoConfig);
			case USERNAME_PASSWORD:
				return initAuthenticatedMongoConnection(mongoConfig);
			default:
				throw new IllegalArgumentException("Unsupported Mongo authentication type: " + mongoAuth.getType());
		}
	}

	private Mongo initUnauthenticatedMongoConnection(MongoConnectionConfig mongoConfig) {
		return new MongoClient(mongoConfig.getHost(), mongoConfig.getPort());
	}

	private Mongo initAuthenticatedMongoConnection(MongoConnectionConfig mongoConfig) {
		UsernamePasswordMongoAuthentication mongoAuth = (UsernamePasswordMongoAuthentication) mongoConfig.getAuth();
		String userName = mongoAuth.getUserName();
		String password = mongoAuth.getPassword();
		String decryptedUserName = encryptor.decrypt(userName);
		String decryptedPassword = encryptor.decrypt(password);
		MongoCredential credential = MongoCredential.createCredential(
				decryptedUserName,
				mongoConfig.getDbName(),
				decryptedPassword.toCharArray()
		);
		ServerAddress serverAddress = new ServerAddress(mongoConfig.getHost(), mongoConfig.getPort());
		return new MongoClient(serverAddress, Collections.singletonList(credential));
	}

}