// Copyright (c) Microsoft Corporation.  All rights reserved.
//

using System;
// using System.Collections.Generic;
using System.IO;

using System.Compiler;

namespace Microsoft.Ddue.Tools.Reflection {

    public class OrcasNamer : ApiNamer {

        public override string GetMemberName(Member member) {

            using (TextWriter writer = new StringWriter()) {

                switch (member.NodeType) {
                    case NodeType.Field:
                        writer.Write("F:");
                        WriteField((Field)member, writer);
                        break;
                    case NodeType.Property:
                        writer.Write("P:");
                        WriteProperty((Property)member, writer);
                        break;
                    case NodeType.Method:
                        writer.Write("M:");
                        WriteMethod((Method)member, writer);
                        break;
                    case NodeType.InstanceInitializer:
                        writer.Write("M:");
                        WriteConstructor((InstanceInitializer)member, writer);
                        break;
                    case NodeType.StaticInitializer:
                        writer.Write("M:");
                        WriteStaticConstructor((StaticInitializer)member, writer);
                        break;
                    case NodeType.Event:
                        writer.Write("E:");
                        WriteEvent((Event)member, writer);
                        break;
                }

                return (writer.ToString());

            }

        }

        public override string GetNamespaceName(Namespace space) {
            using (TextWriter writer = new StringWriter()) {
                writer.Write("N:");
                WriteNamespace(space, writer);
                return (writer.ToString());
            }
        }

        public override string GetTypeName(TypeNode type) {
            using (TextWriter writer = new StringWriter()) {
                writer.Write("T:");
                WriteType(type, writer);
                return (writer.ToString());
            }
        }


        private static string GetName(Member entity) {

            using (TextWriter writer = new StringWriter()) {

                TypeNode type = entity as TypeNode;
                if (type != null) {
                    writer.Write("T:");
                    WriteType(type, writer);
                    return (writer.ToString());
                }

                switch (entity.NodeType) {
                    case NodeType.Namespace:
                        writer.Write("N:");
                        WriteNamespace(entity as Namespace, writer);
                        break;
                    case NodeType.Field:
                        writer.Write("F:");
                        WriteField(entity as Field, writer);
                        break;
                    case NodeType.Property:
                        writer.Write("P:");
                        WriteProperty(entity as Property, writer);
                        break;
                    case NodeType.Method:
                        writer.Write("M:");
                        WriteMethod(entity as Method, writer);
                        break;
                    case NodeType.InstanceInitializer:
                        writer.Write("M:");
                        WriteConstructor(entity as InstanceInitializer, writer);
                        break;
                    case NodeType.StaticInitializer:
                        writer.Write("M:");
                        WriteStaticConstructor(entity as StaticInitializer, writer);
                        break;
                    case NodeType.Event:
                        writer.Write("E:");
                        WriteEvent(entity as Event, writer);
                        break;
                }

                return (writer.ToString());

            }

        }

        private static void WriteConstructor(InstanceInitializer constructor, TextWriter writer) {
            WriteType(constructor.DeclaringType, writer);
            writer.Write(".#ctor");
            WriteParameters(constructor.Parameters, writer);
        }

        private static void WriteEvent(Event trigger, TextWriter writer) {
            WriteType(trigger.DeclaringType, writer);

            Event eiiTrigger = null;
            if (trigger.IsPrivate && trigger.IsVirtual) {
                Event[] eiiTriggers = ReflectionUtilities.GetImplementedEvents(trigger);
                if (eiiTriggers.Length > 0) eiiTrigger = eiiTriggers[0];
            }

            if (eiiTrigger != null) {
                TypeNode eiiType = eiiTrigger.DeclaringType;
                TextWriter eiiWriter = new StringWriter();

                if (eiiType != null && eiiType.Template != null)
                {
                    writer.Write(".");
                    WriteTemplate(eiiType, writer);
                }
                else
                {
                    WriteType(eiiType, eiiWriter);
                    writer.Write(".");
                    writer.Write(eiiWriter.ToString().Replace('.', '#'));
                }

                writer.Write("#");
                writer.Write(eiiTrigger.Name.Name);
            } else {
                writer.Write(".{0}", trigger.Name.Name);
            }
        }

        private static void WriteField(Field field, TextWriter writer) {
            WriteType(field.DeclaringType, writer);
            writer.Write(".{0}", field.Name.Name);
        }

        private static void WriteMethod(Method method, TextWriter writer) {
            string name = method.Name.Name;
            WriteType(method.DeclaringType, writer);

            Method eiiMethod = null;
            if (method.IsPrivate && method.IsVirtual) {
                MethodList eiiMethods = method.ImplementedInterfaceMethods;
                if (eiiMethods.Count > 0) eiiMethod = eiiMethods[0];
            }
            if (eiiMethod != null) { //explicitly implemented interface
                TypeNode eiiType = eiiMethod.DeclaringType;
                TextWriter eiiWriter = new StringWriter();


                //we need to keep the param names instead of turning them into numbers
                //get the template to the right format
                if (eiiType != null && eiiType.Template != null)
                {
                    writer.Write(".");
                    WriteTemplate(eiiType, writer);
                }
                else //revert back to writing the type the old way if there is no template
                {
                    WriteType(eiiType, eiiWriter);
                    writer.Write(".");
                    writer.Write(eiiWriter.ToString().Replace('.', '#'));
                }

                writer.Write("#");
                writer.Write(eiiMethod.Name.Name);
            } else {
                writer.Write(".{0}", name);
            }
            if (method.IsGeneric) {
                TypeNodeList genericParameters = method.TemplateParameters;
                if (genericParameters != null) {
                    writer.Write("``{0}", genericParameters.Count);
                }
            }
            WriteParameters(method.Parameters, writer);
            // add ~ for conversion operators
            if ((name == "op_Implicit") || (name == "op_Explicit")) {
                writer.Write("~");
                WriteType(method.ReturnType, writer);
            }

        }

        // The actual logic to construct names

        private static void WriteNamespace(Namespace space, TextWriter writer) {
            writer.Write(space.Name);
        }

        private static void WriteParameters(ParameterList parameters, TextWriter writer) {
            if ((parameters == null) || (parameters.Count == 0)) return;
            writer.Write("(");
            for (int i = 0; i < parameters.Count; i++) {
                if (i > 0) writer.Write(",");
                WriteType(parameters[i].Type, writer);
            }
            writer.Write(")");
        }

        private static void WriteProperty(Property property, TextWriter writer) {
            WriteType(property.DeclaringType, writer);
            //Console.WriteLine( "{0}::{1}", property.DeclaringType.FullName, property.Name );

            Property eiiProperty = null;
            if (property.IsPrivate && property.IsVirtual) {
                Property[] eiiProperties = ReflectionUtilities.GetImplementedProperties(property);
                if (eiiProperties.Length > 0) eiiProperty = eiiProperties[0];
            }



            if (eiiProperty != null) {
                TypeNode eiiType = eiiProperty.DeclaringType;
                TextWriter eiiWriter = new StringWriter();


                if (eiiType != null && eiiType.Template != null)
                {
                    writer.Write(".");
                    WriteTemplate(eiiType, writer);
                }
                else
                {
                    WriteType(eiiType, eiiWriter);
                    writer.Write(".");
                    writer.Write(eiiWriter.ToString().Replace('.', '#'));
                }

                writer.Write("#");
                writer.Write(eiiProperty.Name.Name);
            } else {
                writer.Write(".{0}", property.Name.Name);
            }
            ParameterList parameters = property.Parameters;
            WriteParameters(parameters, writer);
        }

        private static void WriteStaticConstructor(StaticInitializer constructor, TextWriter writer) {
            WriteType(constructor.DeclaringType, writer);
            writer.Write(".#cctor");
            WriteParameters(constructor.Parameters, writer);
        }

        /// <summary>
        /// Used for explicitly implemented interfaces to convert the template to the
        /// format used in the comments file.
        /// </summary>
        /// <param name="type">EII Type</param>
        /// <param name="writer"></param>
        private static void WriteTemplate(TypeNode eiiType, TextWriter writer)
        {
            string eiiClean = eiiType.Template.ToString();
            eiiClean = eiiClean.Replace('.', '#');
            eiiClean = eiiClean.Replace(',', '@'); //change the seperator between params
            eiiClean = eiiClean.Replace('<', '{'); //change the parameter brackets
            eiiClean = eiiClean.Replace('>', '}');
            writer.Write(eiiClean);
        }

        private static void WriteType(TypeNode type, TextWriter writer) {
            switch (type.NodeType) {
                case NodeType.ArrayType:
                    ArrayType array = type as ArrayType;
                    WriteType(array.ElementType, writer);
                    writer.Write("[");
                    if (array.Rank > 1) {
                        for (int i = 0; i < array.Rank; i++) {
                            if (i > 0) writer.Write(",");
                            writer.Write("0:");
                        }
                    }
                    writer.Write("]");
                    break;
                case NodeType.Reference:
                    Reference reference = type as Reference;
                    TypeNode referencedType = reference.ElementType;
                    WriteType(referencedType, writer);
                    writer.Write("@");
                    break;
                case NodeType.Pointer:
                    Pointer pointer = type as Pointer;
                    WriteType(pointer.ElementType, writer);
                    writer.Write("*");
                    break;
                case NodeType.OptionalModifier:
                    TypeModifier optionalModifierClause = type as TypeModifier;
                    WriteType(optionalModifierClause.ModifiedType, writer);
                    writer.Write("!");
                    WriteType(optionalModifierClause.Modifier, writer);
                    break;
                case NodeType.RequiredModifier:
                    TypeModifier requiredModifierClause = type as TypeModifier;
                    WriteType(requiredModifierClause.ModifiedType, writer);
                    writer.Write("|");
                    WriteType(requiredModifierClause.Modifier, writer);
                    break;
                default:
                    if (type.IsTemplateParameter) {
                        ITypeParameter gtp = (ITypeParameter)type;
                        if (gtp.DeclaringMember is TypeNode) {
                            writer.Write("`");
                        } else if (gtp.DeclaringMember is Method) {
                            writer.Write("``");
                        } else {
                            throw new InvalidOperationException("Generic parameter not on type or method.");
                        }
                        writer.Write(gtp.ParameterListIndex);
                    } else {
                        // namespace
                        TypeNode declaringType = type.DeclaringType;
                        if (declaringType != null) {
                            // names of nested types begin with outer type name
                            WriteType(declaringType, writer);
                            writer.Write(".");
                        } else {
                            // otherwise just prepend the namespace
                            Identifier space = type.Namespace;
                            if ((space != null) && !String.IsNullOrEmpty(space.Name)) {
                                //string space = type.Namespace.Name;
                                //if (space != null && space.Length > 0) {
                                writer.Write(space.Name);
                                writer.Write(".");
                            }
                        }
                        // name
                        writer.Write(type.GetUnmangledNameWithoutTypeParameters());
                        // generic parameters
                        if (type.IsGeneric) {
                            // number of parameters
                            TypeNodeList parameters = type.TemplateParameters;
                            if (parameters != null) {
                                writer.Write("`{0}", parameters.Count);
                            }
                            // arguments
                            TypeNodeList arguments = type.TemplateArguments;
                            if ((arguments != null) && (arguments.Count > 0)) {
                                writer.Write("{");
                                for (int i = 0; i < arguments.Count; i++) {
                                    TypeNode argument = arguments[i];
                                    if (i > 0) writer.Write(",");
                                    WriteType(arguments[i], writer);
                                }
                                writer.Write("}");
                            }
                        }
                    }
                    break;
            }
        }

    }

}