/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.bestray.healthcareemr.ServiceImpl;

import com.bestray.healthcarecommonutil.exception.DataAccessException;
import com.bestray.healthcarecommonutil.exception.HealthCareException;
import com.bestray.healthcarecommonutil.exception.ProcessingException;
import com.bestray.healthcarecommonutil.vo.TPermission;
import com.bestray.healthcarecommonutil.vo.TRole;
import com.bestray.healthcarecommonutil.vo.TRolePermission;
import com.bestray.healthcareemr.Dao.UserPermissionDao;
import com.bestray.healthcareemr.Dao.UserRoleDao;
import com.bestray.healthcareemr.Dao.UserRolePermissionDao;
import com.bestray.healthcareemr.Service.UserRolePermissionService;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 *
 * @author user3
 */
@Service
public class UserRolePermissionServiceImpl implements UserRolePermissionService{
    
    @Autowired
    private UserRolePermissionDao userRolePermissionDao;
    @Autowired
    private UserRoleDao userRoleDao;
    @Autowired
    private UserPermissionDao userPermissionDao;

   
    /*public UserRolePermissionServiceImpl(UserRolePermissionDao userRolePermissionDao,UserRoleDao userRoleDao,
            UserPermissionDao userPermissionDao) {
        
        this.userRolePermissionDao = userRolePermissionDao;
        this.userRoleDao = userRoleDao;
        this.userPermissionDao = userPermissionDao;
    }*/
    
    @Override
    public void saveRoleWithPermission(TRole role, List<TPermission> permissionList)throws ProcessingException,IllegalArgumentException,HibernateOptimisticLockingFailureException {
        try{
            final java.util.Date date= new java.util.Date();
            TRolePermission rolePermission = new TRolePermission();
            if(role.getId()!=null && role.getId()>0){
                role.setUpdatedDate(new Timestamp(date.getTime()));
                userRoleDao.updateRole(role);
                List<TRolePermission> permissions = userRolePermissionDao.getRolePermission(role);
                userRolePermissionDao.deletepermissions(permissions);
                rolePermission.setRoleId(role);
                for(TPermission permission:permissionList){
                    rolePermission.setPermissionId(permission);
                    userRolePermissionDao.saveRoleAndPermission(rolePermission);
                }
            }else{
                
                role.setCreatedDate(new Timestamp(date.getTime()));
                rolePermission.setCreatedDate(new Timestamp(date.getTime()));
                userRoleDao.saveRole(role);
                rolePermission.setRoleId(role);
                for(TPermission permission:permissionList){
                    rolePermission.setPermissionId(permission);
                    userRolePermissionDao.saveRoleAndPermission(rolePermission);
                }
            }
        }catch(  HibernateOptimisticLockingFailureException | IllegalArgumentException ex){
            Logger.getLogger(UserSetupServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw ex;
        }catch(DataAccessException e){
            Logger.getLogger(UserSetupServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(UserSetupServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }
    
    @Transactional(readOnly=true)
    @Override
    public List<TRolePermission> findRolePermissions(Long roleId) throws ProcessingException{
        try{
            List<TPermission> permissionList = userPermissionDao.getPermissionList();
            TRole role = userRoleDao.getRoleByRoleId(roleId);
            Map<TPermission,TRolePermission> rolePermMap = new LinkedHashMap<TPermission,TRolePermission>();
            List<TRolePermission> rolePermissionForThis = userRolePermissionDao.getRolePermission(role);

            for(final TPermission permission:permissionList){

               TRolePermission rolePermission =  (TRolePermission) CollectionUtils.select(rolePermissionForThis, new Predicate() {
                   @Override
                      public boolean evaluate(Object o) {
                      TRolePermission rolePerm = (TRolePermission)o;
                     return rolePerm.getPermissionId().getId() == permission.getId();
                  }
             });
               if(rolePermission != null){
                   rolePermission.setChecked(true);
                   rolePermMap.put(permission, rolePermission);
               }else{
                   rolePermission = new TRolePermission();
                   rolePermission.setPermissionId(permission);
                   rolePermission.setRoleId(role);
                   rolePermission.setChecked(false);
                   rolePermMap.put(permission, rolePermission);
               }           
            }
             return new ArrayList<TRolePermission>(rolePermMap.values());
        }catch(DataAccessException e){
            throw new ProcessingException();
        }
    }
    
    @Override
    public void saveRolePermissions(List<TRolePermission> rolePermissions) throws ProcessingException,IllegalArgumentException {
       try{ 
        for(TRolePermission rolePerm :rolePermissions){
            if(rolePerm.isChecked()){
                if(rolePerm.getId() == null){
                    userRolePermissionDao.saveRoleAndPermission(rolePerm);
                }
            }else{
                if(rolePerm.getId() != null){
                    userRolePermissionDao.deleteRolePermission(rolePerm);
                }
            }
        }
       }catch(IllegalArgumentException e){
           throw e;
       }catch(DataAccessException e){
            throw new ProcessingException();
        }
     }
    
    @Override
    public void saveRoleWithPermission(TRolePermission newrolepermission) throws ProcessingException {
        try{
            userRolePermissionDao.saveRoleWithPermission(newrolepermission);
        }catch(DataAccessException e){
            throw new ProcessingException();
        }
    }
    
    @Override
    public TRolePermission getRolePermission(TRole role, TPermission selectedpermission) throws ProcessingException {
        try{
            return userRolePermissionDao.getRolePermission(role,selectedpermission);
        }catch(DataAccessException e){
            throw new ProcessingException();
        }
    }
    
    @Override
    public void deletePermissionFromRole(TRolePermission rolepermission) throws ProcessingException,IllegalArgumentException {
        try{
            userRolePermissionDao.deletePermissionFromRole(rolepermission);
        }catch(IllegalArgumentException e){
            throw e;
        }catch(DataAccessException e){
            throw new ProcessingException();
        }
    }

    @Override
    public List<TRolePermission> getRolePermission(TRole roleId) throws ProcessingException {
        try{
            return userRolePermissionDao.getRolePermission(roleId);
        }catch(DataAccessException e){
            throw new ProcessingException();
        }
    }
    
}