package shst.medicina.fichasclinicas.logic;

import java.sql.Timestamp;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;

import pt.evolute.data.ProviderSpringBean;
import shst.medicina.fichasclinicas.beans.EvoMessageBean;
import shst.medicina.fichasclinicas.beans.EvoMessageTypeBean;
import shst.medicina.fichasclinicas.beans.EvoResponseBean;
import shst.medicina.fichasclinicas.beans.fichasclinicas.FcTipoFichaBeanData;
import shst.medicina.fichasclinicas.data.fichasclinicas.FcTipoFichaData;

import com.evolute.module.utilizadores.data.EvoUsrPermissionData;
import com.evolute.module.utilizadores.data.EvoUsrRoleData;
import com.evolute.module.utilizadores.data.EvoUsrRolesPermissionsData;
import com.evolute.module.utilizadores.data.EvoUsrUserData;
import com.evolute.module.utilizadores.data.EvoUsrUsersRolesData;
import com.evolute.module.utilizadores.users.provider.UsersDataProvider;
import com.evolute.utils.arrays.Virtual2DArray;
import com.evolute.utils.error.ErrorLogger;
import com.evolute.utils.sql.Expression;
import com.evolute.utils.sql.Field;
import com.evolute.utils.sql.Select2;

public class LoginLogic
{
	@Autowired(required = true)
	@Qualifier("defaultProvider")
	ProviderSpringBean fichasProvidersBean;
	
	public EvoResponseBean doLogin(HttpServletRequest req, String login, String pass) {

		
		EvoResponseBean rsp = new EvoResponseBean();
		EvoMessageBean mb = new EvoMessageBean();
		rsp.addMessage(mb);
		
		EvoUsrUserData user = null;
		
		try 
		{
			user = UsersDataProvider.getProvider().loadUserByUsernamePasswordActive(login, pass, null);
			if(user != null )
			{
				user.setLast_login(new Timestamp(System.currentTimeMillis()));
				user.save();
				req.getSession().setAttribute("user", user);
				
				Authentication ssa = authenticate(login,pass);
				SecurityContextHolder.getContext().setAuthentication(ssa);
				
				
				
				
				List<FcTipoFichaData> tfl = fichasProvidersBean.getENTITY_PROVIDER().listLoad(FcTipoFichaData.class, new Field(FcTipoFichaData.DELETED_STAMP).isEqual(null), new String[]{FcTipoFichaData.DESCRICAO}, null);
				List<FcTipoFichaBeanData> tflBean = new LinkedList<FcTipoFichaBeanData>();
				for(FcTipoFichaData i : tfl)
				{
					FcTipoFichaBeanData ib = new FcTipoFichaBeanData();
					ib.setMapData(i.getPropertiesValues(new String[]{FcTipoFichaData.ID,FcTipoFichaData.DESCRICAO}));
					tflBean.add(ib);
				}
				
				
				Map<String,Object> loginData = new HashMap<String, Object>();
				loginData.put("username", user.getName());
				loginData.put("tipoFichas", tflBean);
				
				
				rsp.setData(loginData);
				rsp.setSuccess(true);
				mb.setType(EvoMessageTypeBean.INFO);
				mb.setMessageData("login com sucesso");				
			}
			else
			{
				rsp.setData(false);
				rsp.setSuccess(false);
				mb.setType(EvoMessageTypeBean.SECURITYEXCEPTION);
				mb.setMessageData("utilizador e/ou password inv\u00e1lidos");
			}
			
			
		} 
		catch (Exception ex)
		{
			rsp.setData(false);
			rsp.setSuccess(false);
			mb.setType(EvoMessageTypeBean.ERROR);
			mb.setMessageData("Erro no processo de valida\u00e7\u00e3o do login!");
			
			ErrorLogger.logException(ex, Level.SEVERE);
		}
		
		return rsp;
		
	}
	
	
	private Authentication authenticate(String login, String password)
	{
		String[] tables = new String[]{
				EvoUsrUserData.TABLENAME,
				EvoUsrUsersRolesData.TABLENAME,
				EvoUsrRoleData.TABLENAME,
				EvoUsrRolesPermissionsData.TABLENAME,
				EvoUsrPermissionData.TABLENAME
		};
		
		Integer[] joins = new Integer[]{Select2.JOIN_INNER,
				Select2.JOIN_INNER,
				Select2.JOIN_INNER,
				Select2.JOIN_INNER
		};
		
		Expression[] joinsExpressions = new Expression[]{
				new Field(EvoUsrUsersRolesData.USER_ID_FULL).isEqual(new Field(EvoUsrUserData.ID_FULL)),
				new Field(EvoUsrRoleData.ID_FULL).isEqual(new Field(EvoUsrUsersRolesData.ROLE_ID_FULL)).and(new Field(EvoUsrRoleData.DELETED_STAMP_FULL).isEqual(null)),
				new Field(EvoUsrRolesPermissionsData.ROLE_ID_FULL).isEqual(new Field(EvoUsrRoleData.ID_FULL)),
				new Field(EvoUsrPermissionData.ID_FULL).isEqual(new Field(EvoUsrRolesPermissionsData.PERMISSION_ID_FULL)).and(new Field(EvoUsrPermissionData.DELETED_DATE_FULL).isEqual(null)),

		};
		
		String[] fields = new String[]{EvoUsrPermissionData.KEY_FULL};
		
		Expression whereExpression = new Field(EvoUsrUserData.ACTIVE_FULL).isEqual(true)
				.and(new Field(EvoUsrUserData.DELETED_STAMP_FULL).isEqual(null))
				.and(new Field(EvoUsrUserData.LOGIN_FULL).isEqual(login));
		
		Select2 permissionKeysQuery = new Select2(tables, joins, joinsExpressions, fields, whereExpression, null, null, null, null);
		
		Collection<GrantedAuthority> keys = new LinkedList<GrantedAuthority>();
		
		
		
		try
		{
			Virtual2DArray result = fichasProvidersBean.getDBMANAGER().getSharedExecuter(this).executeQuery(permissionKeysQuery);
			for(int i=0;i<result.rowCount();++i)
			{
				 GrantedAuthority key = new SimpleGrantedAuthority((String) result.get(i,0));
				 keys.add(key);
			}
			
			return new UsernamePasswordAuthenticationToken( login, password, keys );
		}
		catch(Exception ex)
		{
			RuntimeException re = new RuntimeException("DataBase Communication Error", ex);
			ErrorLogger.logException(re);
			throw re;
		}
	}
}