/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 *
 * $Header:$
 */
package org.apache.beehive.controls.runtime.generator;

import java.util.Collection;

import com.sun.mirror.declaration.ClassDeclaration;
import com.sun.mirror.declaration.FieldDeclaration;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
import com.sun.mirror.type.DeclaredType;
import com.sun.mirror.type.InterfaceType;
import com.sun.mirror.type.TypeMirror;
import com.sun.mirror.type.MirroredTypeException;

import org.apache.beehive.controls.api.bean.ControlExtension;
import org.apache.beehive.controls.api.bean.ControlInterface;
import org.apache.beehive.controls.api.bean.Control;
import org.apache.beehive.controls.api.versioning.VersionRequired;
import org.apache.beehive.controls.runtime.generator.apt.TwoPhaseAnnotationProcessor;

/**
 * The AptControlField class contains information about a field that refers to a nested control.
 */
public class AptControlField extends AptEventField
{
    /**
     * Base constructor, protected so only a custom subclass can invoke
     * @param controlClient the declaring AptType
     */
    public AptControlField(AptType controlClient, FieldDeclaration controlDecl,
                           TwoPhaseAnnotationProcessor ap)
    {
        super( controlDecl );
        _controlClient = controlClient;
        _ap = ap;
        _controlBean = new ControlBean(getControlInterface());
    }

    /**
     * Does this control field have a VersionRequired annotation?
     * @return <code>true</code> if there is a version required annotation; <code>false</code> otherwise
     */
    public boolean hasVersionRequired()
    {
        return ( _fieldDecl.getAnnotation( VersionRequired.class ) != null );
    }

    /**
     * Initializes the ControlInterface associated with this ControlField
     */
    protected AptControlInterface initControlInterface()
    {
        TypeMirror controlType = _fieldDecl.getType();
        if (! (controlType instanceof DeclaredType))
        {
            _ap.printError( _fieldDecl, "control.field.bad.type" );
            return null;
        }

        //
        // The field can either be declared as the bean type or the public interface type.
        // If it is the bean type, then we need to reflect to find the public interface
        // type it implements.
        //
        TypeDeclaration typeDecl = ((DeclaredType)controlType).getDeclaration();
        InterfaceDeclaration controlIntf = null;

        //
        // It is possible that the declared type is associated with a to-be-generated
        // bean type.  In this case, look for the associated control interface on the
        // processor input list.
        //
        if ( typeDecl == null )
        {
            String className = controlType.toString();
            String intfName = className.substring(0, className.length() - 4);
            String interfaceHint = getControlInterfaceHint();
            controlIntf = (InterfaceDeclaration)_ap.getAnnotationProcessorEnvironment().getTypeDeclaration(intfName);

            if (controlIntf == null)
            {
                // The specified class name may not be fully qualified.  In this case, the
                // best we can do is look for a best fit match against the input types
                for (TypeDeclaration td :_ap.getAnnotationProcessorEnvironment().getSpecifiedTypeDeclarations())
                {
                    // if an interface hint was provided, use it to find the control interface,
                    // if not provided try to find the control interface by matching simple names.
                    if (interfaceHint != null) {
                        if (td instanceof InterfaceDeclaration &&
                                td.getQualifiedName().equals(interfaceHint))
                        {
                            controlIntf = (InterfaceDeclaration)td;
                            break;
                        }
                    }
                    else {
                        if (td instanceof InterfaceDeclaration &&
                            td.getSimpleName().equals(intfName))
                        {
                            controlIntf = (InterfaceDeclaration)td;
                            break;
                        }
                    }
                }
            }
        }
        else if (typeDecl instanceof ClassDeclaration)
        {
            Collection<InterfaceType> implIntfs = ((ClassDeclaration)typeDecl).getSuperinterfaces();
            for (InterfaceType intfType : implIntfs)
            {
                InterfaceDeclaration intfDecl = intfType.getDeclaration();

                if ( intfDecl == null )
                    return null;
                
                if (intfDecl.getAnnotation(ControlInterface.class) != null||
                    intfDecl.getAnnotation(ControlExtension.class) != null)
                {
                    controlIntf = intfDecl;
                    break;
                }
            }
        }
        else if (typeDecl instanceof InterfaceDeclaration)
        {
            controlIntf = (InterfaceDeclaration)typeDecl;
        }

        if (controlIntf == null)
        {
            _ap.printError( _fieldDecl, "control.field.bad.type.2" );
            return null;
        }

        return new AptControlInterface(controlIntf, _ap);
    }

    /**
     * Get the interface hint attribute value (as a string) from the Control annotation,
     * if it wasn't specified return null.
     */
    private String getControlInterfaceHint() {

        Control controlAnnotation = _fieldDecl.getAnnotation(Control.class);
        String interfaceHint = null;
        try {
            // always excepts
            controlAnnotation.interfaceHint();
        } catch (MirroredTypeException mte) {
            interfaceHint = ("java.lang.Object".equals(mte.getQualifiedName())) ? null : mte.getQualifiedName();
        }
        return interfaceHint;
    }

    /**
     * Returns the ControlBean associated with this ControlField
     */
    public ControlBean getControlBean() { return _controlBean; }

    private TwoPhaseAnnotationProcessor _ap;
    private AptType _controlClient;
    private ControlBean _controlBean;
}