internal enum DtoTypeKind
{
  Interface,
  Enum,
  Class
}

internal class DtoType
{
  public string Name { get; set; }
  public DtoTypeKind Kind { get; set; }
  public IEnumerable<DtoMember> Members { get; set; }
}

internal class DtoMember
{
  public string Name { get; set; }
  public Type Type { get; set; }
}

internal static class MetadataHelper
{
  public static DtoType[] GetDtoTypesMetadata(IEnumerable<Type> types)
  {
      return types
          .Where(t => !t.IsAbstract) // We are not interested in abstract classes
          .Where(t => t.GetCustomAttribute<DataContractAttribute>() != null)
          .Select(t => new DtoType
          {
              Name = t.Name,
              // struct => interface
              // class => class
              // enum => enum. Must check for enum first because it is a ValueType and we want to avoid enums to be generaed as interfaces
              Kind = t.IsEnum
                      ? DtoTypeKind.Enum
                      : t.IsValueType
                          ? DtoTypeKind.Interface
                          : DtoTypeKind.Class,
              Members = t.IsEnum // For enum types we should get its values except the "value__" field
                  ? t.GetFields()
                      .Where(f => f.GetCustomAttribute<DataMemberAttribute>() != null && f.Name != "value__")
                      .Select(f => new DtoMember
                      {
                          Name = f.Name,
                          Type = f.FieldType
                      })
                  : t.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                      .Where(p => p.GetCustomAttribute<DataMemberAttribute>() != null)
                      .Select(p => new DtoMember
                      {
                          Name = p.Name,
                          Type = p.PropertyType
                      })
          })
          .ToArray();
  }
}

internal partial class TypesGenerator
{
  public DtoType[] DtoTypes { get; set; }

  private IEnumerable<DtoType> Interfaces { get { return DtoTypes.Where(t => t.Kind == DtoTypeKind.Class || t.Kind == DtoTypeKind.Interface); } }
  private IEnumerable<DtoType> Enums { get { return DtoTypes.Where(t => t.Kind == DtoTypeKind.Enum); } }
}

<#@ template language="C#" visibility="internal" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Collections.Generic" #>
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version: <#= Environment.Version #>
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

"use strict";

// Interfaces
<# foreach(var @interface in this.Interfaces) { #>

export interface <#= @interface.Name #> {

<#    foreach(var member in @interface.Members) { #>
  <#= member.Name#>?: <#= GetTypeScriptFieldTypeName(member.Type) #>;
<#    } #>
}
<# } #>


// Enums
<# foreach(var @enum in this.Enums) { #>

export enum <#= @enum.Name #> {
<#    foreach(var member in @enum.Members) { #>
  <#= member.Name #> = <#= (int)Enum.Parse(member.Type, member.Name) #>,
<#    } #>
}
<# } #>
<#+
  /// <summary>
  /// Returns a corresponding TypeScript type for a given .NET type
  /// </summary>
  public static string GetTypeScriptFieldTypeName(Type type)
  {
      var numberTypes = new HashSet<Type>
      {
          typeof(sbyte), typeof(byte), typeof(short),
          typeof(ushort), typeof(int), typeof(uint),
          typeof(long), typeof(ulong), typeof(float),
          typeof(double), typeof(decimal)
      };
      var stringTypes = new HashSet<Type>
      {
          typeof(char), typeof(string), typeof(Guid)
      };

      var result = "";
      var isCollectionType = false;
      // Check if it is a generic. We support only generics which are compatible with IEnumerable<T> and have only one generic argument
      if (type.IsGenericType) {
          if (!typeof(IEnumerable<object>).IsAssignableFrom(type) && type.GetGenericArguments().Length > 1) {
              throw new Exception(string.Format("The generic type {0} must implement IEnumerable<T> and must have no more than 1 generic argument.", type.FullName));
          }
          // strip the generic type leaving the first generic argument
          type = type.GetGenericArguments()[0];
          isCollectionType = true;
      }

      // Check if it is a primitive type
      if (numberTypes.Contains(type)) result = "number";
      else if (stringTypes.Contains(type)) result = "string";
      else if (type == typeof(bool)) result = "boolean";
      // It is enum/class/struct -> return its name as-is
      else result = type.Name;

      if(isCollectionType) result += "[]";

      return result;
  }
#>

static void Main(string[] args)
{
  if (args.Length == 0 || args[0].IndexOfAny(Path.GetInvalidPathChars()) >= 0)
  {
      throw new ArgumentException("Invalid argument. First argument should be a valid file path.");
  }

  var fileName = args[0];
  var typesMetadata = MetadataHelper.GetDtoTypesMetadata(typeof(Todo).Assembly.ExportedTypes);
  var typesGenerator = new TypesGenerator { DtoTypes = typesMetadata };
  File.WriteAllText(fileName, typesGenerator.TransformText().Trim());
}