package my.application;

import java.util.*;
import java.util.logging.*;
import jp.co.blanche_conseiller.commons.util.*;
import my.application.SecurityRole;


public enum BookCloseLockLevel {

    PARTIALLY_CLOSED("xxxxx", new SecurityRole[] {SecurityRole.ACCOUNTANT}, new SecurityRole[] {SecurityRole.ACCOUNTANT}) {
        public boolean isReadyToLock(final Quarter target, final Quarter previousOfTarget) {
            assert (target != null);
            Logger logger = getLogger();
            logger.fine("Checking if the quarter is ready to be locked by PARTIALLY_CLOSED lock.");
            if (logger.isLoggable(Level.FINEST)) {
                logger.fine(String.format("The target Quarter is : %s", target.toString()));
            }
            if (target.getEnds().compareTo(new Date()) >= 0) {
                logger.finer(String.format("PARTIALLY_CLOSED.isReadyToLock returns false, because the day specified by target.ends (%tD) has not been passed.", target.getEnds()));
                return false;
            }
            if (previousOfTarget == null) {
                // If there's no previous Quarter,
                // the target quarter can be locked.
                logger.finer("PARTIALLY_CLOSED.isReadyToLock returns true, because the previous of the target is not specified.");
                return true;
            }
            if (target.isNextTo(previousOfTarget) == false) {
                IllegalArgumentException e = new IllegalArgumentException(
                    String.format("previousOfTarget is not the previous of the target : target=%s : previousOfTarget=%s", target.toString(), previousOfTarget.toString())
                    );
                logger.severe(e.getMessage());
                logger.throwing("blanche.kntv.cdms.model.BookCloseLockLevel", "isReadyToLock", e);
                throw e;
            }
            if (target.getBookCloseLock() == null) {
                logger.finer("PARTIALLY_CLOSED.isReadyToLock returns false, because the previous of the target is not locked by any BookCloseLock.");
                return false;
            }
            if (target.getBookCloseLock().getCloseLockLevel().equals(PARTIALLY_CLOSED) == false) {
                logger.finer(
                    String.format(
                        "PARTIALLY_CLOSED.isReadyToLock returns false, because the lock level of the previous Quarter is not PARTIALLY_CLOSED but %s",
                        target.getBookCloseLock().getCloseLockLevel()
                    ));
                return false;
            }
            logger.finer("PARTIALLY_CLOSED.isReadyToLock returns true, because all the conditions are satisfied.");
            return true;
        }
    };

    static private Logger getLogger() {
        LoggerManager manager = LoggerManager.getInstance();
        Logger logger = manager.getLogger(BookCloseLockLevel.class);
        return logger;
    }

    BookCloseLockLevel(final String displayName, final SecurityRole[] rolesAllowedToModifyObjects, final SecurityRole[] rolesAllowedToChangeLevel) {
        this.displayName = displayName;
        this.rolesAllowedToChangeLevel = rolesAllowedToChangeLevel;
        this.rolesAllowedToModifyObjects = rolesAllowedToModifyObjects;
    }

    public String getDisplayName() {
        return displayName;
    }

    private SecurityRole[] getRolesAllowedToModifyObjects() {
        return rolesAllowedToModifyObjects;
    }

    private SecurityRole[] getRolesAllowedToChangeLevel() {
        return rolesAllowedToChangeLevel;
    }

    public boolean isObjectModificationAllowedBy(final UserSecurityProfile user) {
        assert (user != null);
        Logger logger = getLogger();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("Checking modifiability of object locked in this level : level=%s : user=%s", this.toString(), user.toString()));
        }
        //
        boolean modificationAllowed = false;
        for (SecurityRole role : getRolesAllowedToModifyObjects()) {
            if (user.isUserInRole(role)) {
                modificationAllowed = true;
                //
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine(String.format("Object locked in this level can be modified by specified user : user is in role %s", role.toString()));
                }
                break;
            }
        }
        return modificationAllowed;
    }

    public boolean isLockLevelChangeAllowedBy(final UserSecurityProfile user) {
        boolean changeLevelAllowed = false;
        for (SecurityRole role : getRolesAllowedToChangeLevel()) {
            if (user.isUserInRole(role)) {
                changeLevelAllowed = true;
                break;
            }
        }
        return changeLevelAllowed;
    }

    abstract public boolean isReadyToLock(final Quarter target, final Quarter previousOfTarget);

    final private String displayName;
    final private SecurityRole[] rolesAllowedToModifyObjects;
    final private SecurityRole[] rolesAllowedToChangeLevel;

}