/*
 * Copyright (C) 2015, The Android Open Source Project
 *
 * Licensed 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.
 */

#pragma once

#include <string>
#include <vector>

#include "ast_java.h"
#include "type_namespace.h"

namespace android {
namespace aidl {
namespace java {

class JavaTypeNamespace;

class Type : public ValidatableType {
 public:
  // WriteToParcel flags
  enum { PARCELABLE_WRITE_RETURN_VALUE = 0x0001 };

  // defaultValue is by default set to "null" because that is the default value
  // for most of the types like class and array. default values for built-in
  // types like int, double, boolean, etc. are explicitly set via BasicType
  Type(const JavaTypeNamespace* types, const std::string& name, int kind, bool canWriteToParcel);
  Type(const JavaTypeNamespace* types, const std::string& package, const std::string& name,
       int kind, bool canWriteToParcel, const std::string& declFile = "", int declLine = -1);
  virtual ~Type() = default;

  bool CanWriteToParcel() const override { return m_canWriteToParcel; }

  const ValidatableType* ArrayType() const override { return m_array_type.get(); }
  const ValidatableType* NullableType() const override { return nullptr; }

  virtual std::string JavaType() const { return m_javaType; }
  virtual std::string InstantiableName() const;

  // The namespace where this type is defined in
  const JavaTypeNamespace* GetTypeNamespace() const { return m_types; }

 protected:
  Expression* BuildWriteToParcelFlags(int flags) const;

  const JavaTypeNamespace* m_types;

  std::unique_ptr<Type> m_array_type;

 private:
  Type();
  Type(const Type&);

  std::string m_javaType;
  std::string m_declFile;
  bool m_canWriteToParcel;
};

class BasicArrayType : public Type {
 public:
  BasicArrayType(const JavaTypeNamespace* types, const std::string& name,
                 const std::string& writeArrayParcel,
                 const std::string& createArrayParcel,
                 const std::string& readArrayParcel);

  const ValidatableType* NullableType() const override { return this; }

 private:
  std::string m_writeArrayParcel;
  std::string m_createArrayParcel;
  std::string m_readArrayParcel;
};

class BasicType : public Type {
 public:
  BasicType(const JavaTypeNamespace* types, const std::string& name,
            const std::string& marshallParcel, const std::string& unmarshallParcel,
            const std::string& writeArrayParcel, const std::string& createArrayParcel,
            const std::string& readArrayParcel);

 private:
  std::string m_marshallParcel;
  std::string m_unmarshallParcel;
};

class FileDescriptorArrayType : public Type {
 public:
  explicit FileDescriptorArrayType(const JavaTypeNamespace* types);

  const ValidatableType* NullableType() const override { return this; }
};

class FileDescriptorType : public Type {
 public:
  explicit FileDescriptorType(const JavaTypeNamespace* types);
};

class ParcelFileDescriptorArrayType : public Type {
 public:
  explicit ParcelFileDescriptorArrayType(const JavaTypeNamespace* types);

  const ValidatableType* NullableType() const override { return this; }
};

class ParcelFileDescriptorType : public Type {
 public:
  explicit ParcelFileDescriptorType(const JavaTypeNamespace* types);

  const ValidatableType* NullableType() const override { return this; }
};

class BooleanArrayType : public Type {
 public:
  explicit BooleanArrayType(const JavaTypeNamespace* types);
  const ValidatableType* NullableType() const override { return this; }
};

class BooleanType : public Type {
 public:
  explicit BooleanType(const JavaTypeNamespace* types);
};

class CharArrayType : public Type {
 public:
  explicit CharArrayType(const JavaTypeNamespace* types);
  const ValidatableType* NullableType() const override { return this; }
};

class CharType : public Type {
 public:
  explicit CharType(const JavaTypeNamespace* types);
};

class StringArrayType : public Type {
 public:
  explicit StringArrayType(const JavaTypeNamespace* types);

  const ValidatableType* NullableType() const override { return this; }
};

class StringType : public Type {
 public:
  StringType(const JavaTypeNamespace* types, const std::string& package,
             const std::string& class_name);

  std::string JavaType() const override { return "java.lang.String"; }
  const ValidatableType* NullableType() const override { return this; }
};

class CharSequenceType : public Type {
 public:
  explicit CharSequenceType(const JavaTypeNamespace* types);
};

class RemoteExceptionType : public Type {
 public:
  explicit RemoteExceptionType(const JavaTypeNamespace* types);
};

class RuntimeExceptionType : public Type {
 public:
  explicit RuntimeExceptionType(const JavaTypeNamespace* types);
};

class IBinderArrayType : public Type {
 public:
  explicit IBinderArrayType(const JavaTypeNamespace* types);
  const ValidatableType* NullableType() const override { return this; }
};

class IBinderType : public Type {
 public:
  explicit IBinderType(const JavaTypeNamespace* types);
  const ValidatableType* NullableType() const override { return this; }
};

class IInterfaceType : public Type {
 public:
  explicit IInterfaceType(const JavaTypeNamespace* types);
};

class BinderType : public Type {
 public:
  explicit BinderType(const JavaTypeNamespace* types);
};

class BinderProxyType : public Type {
 public:
  explicit BinderProxyType(const JavaTypeNamespace* types);
};

class ParcelType : public Type {
 public:
  explicit ParcelType(const JavaTypeNamespace* types);
  const ValidatableType* NullableType() const override { return this; }
};

class ParcelableInterfaceType : public Type {
 public:
  explicit ParcelableInterfaceType(const JavaTypeNamespace* types);
};

class MapType : public Type {
 public:
  explicit MapType(const JavaTypeNamespace* types);
  const ValidatableType* NullableType() const override { return this; }
};

class ListType : public Type {
 public:
  explicit ListType(const JavaTypeNamespace* types);

  std::string InstantiableName() const override;
  const ValidatableType* NullableType() const override { return this; }
};

class UserDataArrayType : public Type {
 public:
  UserDataArrayType(const JavaTypeNamespace* types, const std::string& package,
                    const std::string& name, bool builtIn,
                    bool canWriteToParcel, const std::string& declFile = "",
                    int declLine = -1);

  const ValidatableType* NullableType() const override { return this; }
};

class UserDataType : public Type {
 public:
  UserDataType(const JavaTypeNamespace* types, const std::string& package,
               const std::string& name, bool builtIn, bool canWriteToParcel,
               const std::string& declFile = "", int declLine = -1);

  const ValidatableType* NullableType() const override { return this; }
};

class InterfaceType : public Type {
 public:
  InterfaceType(const JavaTypeNamespace* types, const std::string& package, const std::string& name,
                bool builtIn, const std::string& declFile, int declLine, const Type* stub,
                const Type* proxy, const Type* defaultImpl);

  const ValidatableType* NullableType() const override { return this; }
  const Type* GetStub() const { return stub_; }
  const Type* GetProxy() const { return proxy_; }
  const Type* GetDefaultImpl() const { return defaultImpl_; }

 private:
  const Type* stub_;
  const Type* proxy_;
  const Type* defaultImpl_;
};

class ClassLoaderType : public Type {
 public:
  explicit ClassLoaderType(const JavaTypeNamespace* types);
};

class GenericListType : public Type {
 public:
  GenericListType(const JavaTypeNamespace* types, const Type* arg);

  std::string InstantiableName() const override;
  std::string JavaType() const override {
    return "java.util.List<" + m_contained_type->JavaType() + ">";
  }

  const ValidatableType* NullableType() const override { return this; }

 private:
  const Type* m_contained_type;
};

class JavaTypeNamespace : public LanguageTypeNamespace<Type> {
 public:
  JavaTypeNamespace() = default;
  virtual ~JavaTypeNamespace() = default;

  void Init() override;
  bool AddParcelableType(const AidlParcelable& p,
                         const std::string& filename) override;
  bool AddBinderType(const AidlInterface& b,
                     const std::string& filename) override;
  bool AddListType(const std::string& contained_type_name) override;
  bool AddMapType(const std::string& key_type_name,
                  const std::string& value_type_name) override;

  const Type* BoolType() const { return m_bool_type; }
  const Type* IntType() const { return m_int_type; }
  const Type* StringType() const { return m_string_type; }
  const Type* TextUtilsType() const { return m_text_utils_type; }
  const Type* RemoteExceptionType() const { return m_remote_exception_type; }
  const Type* RuntimeExceptionType() const { return m_runtime_exception_type; }
  const Type* IBinderType() const { return m_ibinder_type; }
  const Type* IInterfaceType() const { return m_iinterface_type; }
  const Type* BinderNativeType() const { return m_binder_native_type; }
  const Type* BinderProxyType() const { return m_binder_proxy_type; }
  const Type* ParcelType() const { return m_parcel_type; }
  const Type* ParcelableInterfaceType() const {
    return m_parcelable_interface_type;
  }
  const Type* ContextType() const { return m_context_type; }
  const Type* ClassLoaderType() const { return m_classloader_type; }

 private:
  const Type* m_bool_type{nullptr};
  const Type* m_int_type{nullptr};
  const Type* m_string_type{nullptr};
  const Type* m_text_utils_type{nullptr};
  const Type* m_remote_exception_type{nullptr};
  const Type* m_runtime_exception_type{nullptr};
  const Type* m_ibinder_type{nullptr};
  const Type* m_iinterface_type{nullptr};
  const Type* m_binder_native_type{nullptr};
  const Type* m_binder_proxy_type{nullptr};
  const Type* m_parcel_type{nullptr};
  const Type* m_parcelable_interface_type{nullptr};
  const Type* m_context_type{nullptr};
  const Type* m_classloader_type{nullptr};

  DISALLOW_COPY_AND_ASSIGN(JavaTypeNamespace);
};

extern Expression* NULL_VALUE;
extern Expression* THIS_VALUE;
extern Expression* SUPER_VALUE;
extern Expression* TRUE_VALUE;
extern Expression* FALSE_VALUE;

}  // namespace java
}  // namespace aidl
}  // namespace android