/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun
 * Microsystems, Inc. All Rights Reserved.
 */
package org.netbeans.modules.refactoring.api;

import java.lang.reflect.Modifier;
import java.util.ArrayList;
import org.netbeans.jmi.javamodel.*;
import org.netbeans.modules.refactoring.CheckUtils;
import org.netbeans.modules.refactoring.CreateMethodElement;
import org.netbeans.modules.refactoring.NbAbstractRefactoring;
import org.openide.util.NbBundle;
import javax.jmi.reflect.RefObject;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import javax.jmi.reflect.RefFeatured;
import org.netbeans.jmi.javamodel.Field;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
import org.netbeans.modules.refactoring.ChangeModElement;
import org.netbeans.modules.refactoring.EncapsulateFieldElement;
import org.netbeans.modules.refactoring.api.Problem;

/**
 *
 * @author  Tomas Hurka
 */
public class EncapsulateFieldRefactoring extends NbAbstractRefactoring {
    private final RefObject jmiObject;
    private Field encapsulatedField;
    private boolean donePreCheck = false;
    private String getterName,setterName;
    private int methodModifiers,fieldModifiers;
    private Method currentGetter,currentSetter;
    private JavaModelPackage modelPackage;
    private static int accessModifiers = Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PUBLIC;
    
    /** Creates a new instance of RenameRefactoring */
    public EncapsulateFieldRefactoring(RefObject jmiObject) {
        this.jmiObject = jmiObject;
        modelPackage = (JavaModelPackage) jmiObject.refImmediatePackage();
    }
    
    public Problem preCheck() {
        fireProgressListenerStart(PRE_CHECK, 2);
        try {
            Problem result = null;

            fireProgressListenerStep();
            if ((jmiObject instanceof Field) && !(jmiObject instanceof EnumConstant)) {
               encapsulatedField=(Field)jmiObject;
            } else {
                result = createProblem(result, true, NbBundle.getMessage(EncapsulateFieldRefactoring.class, "ERR_EncapsulateWrongType"));
            }
            return result;
        } finally {
            fireProgressListenerStop();
        }
    }
    
    public Problem checkParameters(String getter,String setter,int accessModifier,int fieldModifier) {
        //[TODO] some error checks
        return null;
    }
    
    public Problem setParameters(String getter,String setter,int accessModifier,int fieldModifier) {
        Problem result = null;
        
        if (!donePreCheck) {
            result = preCheck();
            if (result != null && result.isFatal()) {
                return result;
            }
        }
        
        fireProgressListenerStart(PARAMETERS_CHECK, 8);
        
        try {
            setterName=setter;
            getterName=getter;
            this.methodModifiers=accessModifier;
            this.fieldModifiers=fieldModifier;
            return result;
        } finally {
            fireProgressListenerStop();
        }
    }
    
    public void setClassPath() {
        setClassPath((Element) jmiObject);
    }
    
    private TypeReference getTypeReference() {
        TypeReference ref=encapsulatedField.getTypeName();
        int dims=encapsulatedField.getDimCount();
        
        ref=(TypeReference)ref.duplicate();
        if (dims>0) {            
            if (ref instanceof ArrayReference) {
                ArrayReference arrRef=(ArrayReference)ref;
                
                arrRef.setDimCount(arrRef.getDimCount()+dims);
            } else {
                ArrayReferenceClass arrClass=((JavaModelPackage)encapsulatedField.refImmediatePackage()).getArrayReference();
                
                ref=arrClass.createArrayReference(null,(MultipartId)ref,dims);
            }
            
        }
        return ref;
    }
    
    private void createGetterAndSetter(Collection elms) {
        String fieldName=encapsulatedField.getName();
        int staticMod=encapsulatedField.getModifiers()&Modifier.STATIC;
        String parName=staticMod!=0?"a"+getCapitalizedName(encapsulatedField):fieldName; //NOI18N
        String getterBody="return ".concat(fieldName).concat(";"); //NOI18N
        String setterBody=(staticMod==0?"this.":"").concat(fieldName).concat(" = ").concat(parName).concat(";"); //NOI18N
        Type fieldType=encapsulatedField.getType();
        ClassDefinition jcls=encapsulatedField.getDeclaringClass();
        JavaModelPackage modelExtent=(JavaModelPackage)jcls.refImmediatePackage();
        TypeReference fieldTypeName=getTypeReference();
        Parameter par=modelExtent.getParameter().createParameter(parName, null, false, null, 0, false);
        int newmods=methodModifiers | staticMod;        
        List features = jcls.getContents();
        ListIterator iter = features.listIterator(features.size());
        ClassMember insertPoint = null;
        JavaMetamodel manager = JavaMetamodel.getManager();
        
        while (iter.hasPrevious()) {
            ClassMember cm = (ClassMember)iter.previous();
            if (!manager.isElementGuarded(cm)) {
                break;
            } else {
                insertPoint = cm;
            }
        }
        par.setTypeName(fieldTypeName);        
        currentGetter=CheckUtils.getMethod(jcls,getterName,Collections.EMPTY_LIST);
        if (currentGetter==null) {
            RefactoringElement getter=new CreateMethodElement(newmods, getterName, fieldTypeName,
                                            Collections.EMPTY_LIST, getterBody, insertPoint, jcls);
            elms.add(getter);
        }
        currentSetter=CheckUtils.getMethod(jcls,setterName,Collections.singletonList(fieldType));
        if (currentSetter==null) {
            RefactoringElement setter=new CreateMethodElement(newmods, setterName, null,
                                        Collections.singletonList(par), setterBody, insertPoint, jcls);
            elms.add(setter);
        }
    }
    
    private static StringBuffer getCapitalizedName(Field field) {
        StringBuffer name=new StringBuffer(field.getName());
        
        name.setCharAt(0,Character.toUpperCase(name.charAt(0)));
        return name;
    }
    
    
    public static String computeSetterName(Field field) {
        StringBuffer name=getCapitalizedName(field);
        
        name.insert(0,"set"); //NOI18N
        return name.toString();
    }
    
    public static String computeGetterName(Field field) {
        StringBuffer name=getCapitalizedName(field);
        Type retVal=field.getType();
        
        if (retVal instanceof PrimitiveType && ((PrimitiveType)retVal).getKind().equals(PrimitiveTypeKindEnum.BOOLEAN))
            name.insert(0,"is"); //NOI18N
        else 
            name.insert(0,"get"); //NOI18N
        return name.toString();
    }
    
    private boolean isOutsideGetterSetter(Element el) {
        while (!(el instanceof Feature))
            el=(Element)el.refImmediateComposite();
        if (el.equals(currentGetter) || el.equals(currentSetter))
            return false;
        return true;
    }
    
    public Problem prepare(Collection elements) {
        
        fireProgressListenerStart(PREPARE, 9);
        try {
            fireProgressListenerStep();
            
            referencesIterator = encapsulatedField.getReferences().iterator();
            // if the field modifier is changed, create the element which
            // changes field's modifier and informs user by item in the tree
            int mods=encapsulatedField.getModifiers();
            
            if ((mods&accessModifiers) != fieldModifiers) {
                int newMods=(mods & ~accessModifiers)|fieldModifiers;
                elements.add(new ChangeModElement(encapsulatedField,newMods));
            }
            createGetterAndSetter(elements);            
            while (referencesIterator.hasNext()) {
                if (cancelRequest) {
                    return null;
                }
                Element usage=(Element) referencesIterator.next();
                
                if (isOutsideGetterSetter(usage))
                    elements.add(new EncapsulateFieldElement(encapsulatedField, (VariableAccess)usage, getterName,setterName));
            }
            return null;
        } finally {
            referencesIterator = null;
            fireProgressListenerStop();
        }
    }
    
    public Field getEncapsulatedField() {
        return encapsulatedField;
    }
}