/*
 * Copyright 2011 gitblit.com.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.gitblit;

import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.gitblit.models.TeamModel;
import com.gitblit.models.UserModel;

/**
 * This class wraps the default user service and is recommended as the starting
 * point for custom user service implementations.
 * 
 * This does seem a little convoluted, but the idea is to allow IUserService to
 * evolve and be replaced without hampering custom implementations.
 * 
 * The most common need for a custom IUserService is to override authentication
 * and then delegate to one of Gitblit's user services. Subclassing this allows
 * for authentication customization without having to keep-up-with IUSerService
 * API changes.
 * 
 * @author James Moger
 * 
 */
public abstract class UserServiceWrapper implements IUserService {

	protected IUserService defaultService;

	private final Logger logger = LoggerFactory.getLogger(UserServiceWrapper.class);

	public UserServiceWrapper() {
	}

	@SuppressWarnings("deprecation")
	@Override
	public final void setup(IStoredSettings settings) {
		File realmFile = GitBlit.getFileOrFolder(Keys.realm.userService, "users.conf");
		if (realmFile.exists()) {
			// load the existing realm file
			if (realmFile.getName().toLowerCase().endsWith(".properties")) {
				// load the v0.5.0 - v0.7.0 properties-based realm file
				defaultService = new FileUserService(realmFile);

				// automatically create a users.conf realm file from the
				// original users.properties file
				File usersConfig = new File(realmFile.getParentFile(), "users.conf");
				if (!usersConfig.exists()) {
					logger.info(MessageFormat.format("Automatically creating {0} based on {1}",
							usersConfig.getAbsolutePath(), realmFile.getAbsolutePath()));
					ConfigUserService configService = new ConfigUserService(usersConfig);
					for (String username : defaultService.getAllUsernames()) {
						UserModel userModel = defaultService.getUserModel(username);
						configService.updateUserModel(userModel);
					}
				}

				// issue suggestion about switching to users.conf
				logger.warn("Please consider using \"users.conf\" instead of the deprecated \"users.properties\" file");
			} else if (realmFile.getName().toLowerCase().endsWith(".conf")) {
				// load the config-based realm file
				defaultService = new ConfigUserService(realmFile);
			}
		} else {
			// Create a new realm file and add the default admin
			// account. This is necessary for bootstrapping a dynamic
			// environment like running on a cloud service.
			// As of v0.8.0 the default realm file is ConfigUserService.
			try {
				realmFile = GitBlit.getFileOrFolder(Keys.realm.userService, "users.conf");
				realmFile.createNewFile();
				defaultService = new ConfigUserService(realmFile);
				UserModel admin = new UserModel("admin");
				admin.password = "admin";
				admin.canAdmin = true;
				admin.excludeFromFederation = true;
				defaultService.updateUserModel(admin);
			} catch (IOException x) {
				logger.error(MessageFormat.format("COULD NOT CREATE REALM FILE {0}!", realmFile), x);
			}
		}

		// call subclass setup
		setupService(settings);
	}

	/**
	 * Subclasses must implement this method.
	 * 
	 * @param settings
	 */
	public abstract void setupService(IStoredSettings settings);

	@Override
	public boolean supportsCookies() {
		return defaultService.supportsCookies();
	}

	@Override
	public char[] getCookie(UserModel model) {
		return defaultService.getCookie(model);
	}

	@Override
	public UserModel authenticate(char[] cookie) {
		return defaultService.authenticate(cookie);
	}

	@Override
	public UserModel authenticate(String username, char[] password) {
		return defaultService.authenticate(username, password);
	}

	@Override
	public UserModel getUserModel(String username) {
		return defaultService.getUserModel(username);
	}

	@Override
	public boolean updateUserModel(UserModel model) {
		return defaultService.updateUserModel(model);
	}

	@Override
	public boolean updateUserModel(String username, UserModel model) {
		return defaultService.updateUserModel(username, model);
	}

	@Override
	public boolean deleteUserModel(UserModel model) {
		return defaultService.deleteUserModel(model);
	}

	@Override
	public boolean deleteUser(String username) {
		return defaultService.deleteUser(username);
	}

	@Override
	public List<String> getAllUsernames() {
		return defaultService.getAllUsernames();
	}

	@Override
	public List<String> getAllTeamNames() {
		return defaultService.getAllTeamNames();
	}

	@Override
	public List<String> getTeamnamesForRepositoryRole(String role) {
		return defaultService.getTeamnamesForRepositoryRole(role);
	}

	@Override
	public boolean setTeamnamesForRepositoryRole(String role, List<String> teamnames) {
		return defaultService.setTeamnamesForRepositoryRole(role, teamnames);
	}

	@Override
	public TeamModel getTeamModel(String teamname) {
		return defaultService.getTeamModel(teamname);
	}

	@Override
	public boolean updateTeamModel(TeamModel model) {
		return defaultService.updateTeamModel(model);
	}

	@Override
	public boolean updateTeamModel(String teamname, TeamModel model) {
		return defaultService.updateTeamModel(teamname, model);
	}

	@Override
	public boolean deleteTeamModel(TeamModel model) {
		return defaultService.deleteTeamModel(model);
	}

	@Override
	public boolean deleteTeam(String teamname) {
		return defaultService.deleteTeam(teamname);
	}

	@Override
	public List<String> getUsernamesForRepositoryRole(String role) {
		return defaultService.getUsernamesForRepositoryRole(role);
	}

	@Override
	public boolean setUsernamesForRepositoryRole(String role, List<String> usernames) {
		return defaultService.setUsernamesForRepositoryRole(role, usernames);
	}

	@Override
	public boolean renameRepositoryRole(String oldRole, String newRole) {
		return defaultService.renameRepositoryRole(oldRole, newRole);
	}

	@Override
	public boolean deleteRepositoryRole(String role) {
		return defaultService.deleteRepositoryRole(role);
	}
}