<#
//*********************************************************
//
//    Copyright (c) Microsoft. All rights reserved.
//    This code is licensed under the Microsoft Public License.
//    THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
//    ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
//    IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
//    PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************
#>
<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#><#@
 output extension=".cs"#><#
 
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);
 
string inputFile = @"../YourEFModelHere.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();
 
EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);
 
// Write out support code to primary template output file
WriteHeader(fileManager);
BeginNamespace(namespaceName, code);
WriteCustomObservableCollection();
EndNamespace(namespaceName);
 
// Emit Entity Types
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{
	fileManager.StartNewFile(entity.Name + "Poco.cs");
 
	BeginNamespace(namespaceName, code);
	bool entityHasNullableFKs = entity.NavigationProperties.Any(np => np.GetDependentProperties().Any(p=>ef.IsNullable(p)));
#>
<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#><#=code.StringBefore(" : ", code.Escape(entity.BaseType))#>Poco : INotifyPropertyChanged
{
 
<#region.Begin("Poco Initialization");#>
 
	private <#=code.Escape(entity)#> _context;
	private CollisionTransEntities _dbEntities;
	public <#=code.Escape(entity)#> Context{ get { return _context; } internal set { _context = value; } }
	public event PropertyChangedEventHandler PropertyChanged;
 
	public <#=code.Escape(entity)#>Poco()
    {
		_context = new <#=code.Escape(entity)#>();
		_context.PropertyChanged += context_PropertyChanged;
		Initialize(true);
	}
 
	public <#=code.Escape(entity)#>Poco(<#=code.Escape(entity)#> context, CollisionTransEntities dbEntities)
    {
        _context = context;
		DbEntities = dbEntities; 
		_context.PropertyChanged += context_PropertyChanged;
		Initialize(false);
    }
 
	private void Initialize(bool skipSubCollectionInitialization)
	{
<#
	foreach (NavigationProperty navProperty in entity.NavigationProperties.Where(np => np.DeclaringType == entity))
	{
		NavigationProperty inverse = ef.Inverse(navProperty);
		if (navProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
		{
			WriteLine("		if (!skipSubCollectionInitialization)");
			WriteLine("			CreateNew" + navProperty.Name + "Collection();");
		}
		if ((inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey) &&
			navProperty.ToEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many)
        {
			WriteLine("		_context." + navProperty.Name + "Reference.AssociationChanged += " + navProperty.Name + "_AssociationChanged;");
		}
	}
#>
	}
 
	private void InitializeSubCollections()
	{
<#
	foreach (NavigationProperty navProperty in entity.NavigationProperties.Where(np => np.DeclaringType == entity))
	{
		NavigationProperty inverse = ef.Inverse(navProperty);
		if (navProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
		{
			WriteLine("		CreateNew" + navProperty.Name + "Collection();");
		}
	}
#>
	}
 
	public CollisionTransEntities DbEntities
	{ 
		get
		{
			return _dbEntities;
		}
		set
		{
			if(_dbEntities == null)
			{
				_dbEntities = value;
				//Now also "Initialize" the sub-collections...
				InitializeSubCollections();
			}
		}
	}
 
	void context_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(e.PropertyName));
    }
 
<#region.End();#>
<#
    region.Begin("Primitive Properties");
 
    foreach (EdmProperty edmProperty in entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity))
    {
        bool isForeignKey = entity.NavigationProperties.Any(np=>np.GetDependentProperties().Contains(edmProperty));
        bool isDefaultValueDefinedInModel = (edmProperty.DefaultValue != null);
        bool generateAutomaticProperty = false;
 
 
 
#>
 
    <#=PropertyVirtualModifier(Accessibility.ForProperty(edmProperty))#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
    {
<#
        if (isForeignKey)
        {
#>
		<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return _context.<#=code.Escape(edmProperty)#>; } //qwer1 Type:<#=code.Escape(edmProperty.TypeUsage)#>
		<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set 
		{ 
			if(_context.<#=code.Escape(edmProperty)#> != value)
			{
				_context.PropertyChanged -= context_PropertyChanged;
				_context.<#=code.Escape(edmProperty)#> = value;
				_context.PropertyChanged += context_PropertyChanged;
				if (PropertyChanged != null)
					PropertyChanged(this, new PropertyChangedEventArgs("<#=code.Escape(edmProperty)#>"));
				<#=entityHasNullableFKs?"//Entity property has nullable-FKs":""#>
			}
		}
<#
        }
        else if (isDefaultValueDefinedInModel)
        {
#>
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get qwer2{ return <#=code.FieldName(edmProperty)#>; }
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
<#
        }
        else
        {
            generateAutomaticProperty = true;
#>
		<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return _context.<#=code.Escape(edmProperty)#>; } //qwer3 Type:<#=code.Escape(edmProperty.TypeUsage)#>
		<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set 
		{ 
			if(_context.<#=code.Escape(edmProperty)#> != value)
			{
				_context.PropertyChanged -= context_PropertyChanged;
				_context.<#=code.Escape(edmProperty)#> = value;
				_context.PropertyChanged += context_PropertyChanged;
				if (PropertyChanged != null)
					PropertyChanged(this, new PropertyChangedEventArgs("<#=code.Escape(edmProperty)#>"));
			}
		}
<#
        }
#>
    }
 
<#
        if (!generateAutomaticProperty)
        {
#>
<#
        }
    }
    region.End();
 
    region.Begin("Complex Properties");
 
    foreach(EdmProperty edmProperty in entity.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == entity))
    {
#>
 
    <#=PropertyVirtualModifier(Accessibility.ForProperty(edmProperty))#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get dfgh{ return <#=code.FieldName(edmProperty)#>; }
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
    }
    private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#> = new <#=code.Escape(edmProperty.TypeUsage)#>();
<#
    }
 
    region.End();
 
    ////////
    //////// Write Navigation properties -------------------------------------------------------------------------------------------
    ////////
 
    region.Begin("Navigation Properties");
 
    foreach (NavigationProperty navProperty in entity.NavigationProperties.Where(np => np.DeclaringType == entity))
    {
        NavigationProperty inverse = ef.Inverse(navProperty);
        if (inverse != null &&  !IsReadWriteAccessibleProperty(inverse))
        {
            inverse = null;
        }
#>
 
<#
        if (navProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
        {
#>
    <#=PropertyVirtualModifier(Accessibility.ForReadOnlyProperty(navProperty))#> ObservableCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco> <#=code.Escape(navProperty)#>
    {
        get //qwer4
        {
            CreateNew<#=code.Escape(navProperty)#>Collection();
            return <#=code.FieldName(navProperty)#>;
        }
        set
        {
<#
            if (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey)
            {
#>
            if (!Object.ReferenceEquals(<#=code.FieldName(navProperty)#>, value))
            {
				CreateNew<#=code.Escape(navProperty)#>Collection();
            }
<#
            }
            else
            {
#>
            CreateNew<#=code.Escape(navProperty)#>Collection();
<#
            }
#>
 
			if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("<#=code.Escape(navProperty)#>"));
        }
    }
    private ObservableCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco> <#=code.FieldName(navProperty)#>;
 
	private void CreateNew<#=code.Escape(navProperty)#>Collection()
    {
        if (<#=code.FieldName(navProperty)#> == null && _context.<#=code.Escape(navProperty)#> != null)
        {
            <#=code.FieldName(navProperty)#> = new ObservableCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco>();
			IEnumerable<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>> efEntities = DbEntities.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Unchanged | EntityState.Deleted).Where(i => i.Entity is <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>).Select(i => i.Entity).Cast<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>>();
            foreach (var item in efEntities)
                <#=code.FieldName(navProperty)#>.Add(new <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco(item, DbEntities));
 
			//This will handle changes originating from the db-entities...
            _context.<#=code.Escape(navProperty)#>.AssociationChanged -= <#=code.Escape(navProperty)#>_AssociationChanged;
            _context.<#=code.Escape(navProperty)#>.AssociationChanged += <#=code.Escape(navProperty)#>_AssociationChanged;
 
			//This will handle changes originating from the User-Interface...
            <#=code.FieldName(navProperty)#>.CollectionChanged -= <#=code.Escape(navProperty)#>Collection_CollectionChanged;
            <#=code.FieldName(navProperty)#>.CollectionChanged += <#=code.Escape(navProperty)#>Collection_CollectionChanged;
        }
		else if (<#=code.FieldName(navProperty)#> != null && _context.<#=code.Escape(navProperty)#> == null)
			<#=code.FieldName(navProperty)#> = null;
    } 
 
	void <#=code.Escape(navProperty)#>Collection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        if (e.NewItems != null && e.NewItems.Count > 0)
		{
            _context.<#=code.Escape(navProperty)#>.AssociationChanged -= <#=code.Escape(navProperty)#>_AssociationChanged;
            foreach (var newItem in e.NewItems)
                _context.<#=code.Escape(navProperty)#>.Add((newItem as <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco).Context);
			_context.<#=code.Escape(navProperty)#>.AssociationChanged += <#=code.Escape(navProperty)#>_AssociationChanged;
		}
        else if(e.OldItems != null && e.OldItems.Count > 0)
		{
            _context.<#=code.Escape(navProperty)#>.AssociationChanged -= <#=code.Escape(navProperty)#>_AssociationChanged;
            foreach (var removedItem in e.OldItems)
                _dbEntities.DeleteObject((removedItem as <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco).Context);
			//_context.<#=code.Escape(navProperty)#>.Remove((removedItem as <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco).Context);
			_context.<#=code.Escape(navProperty)#>.AssociationChanged += <#=code.Escape(navProperty)#>_AssociationChanged;
		}
    }
 
	void <#=code.Escape(navProperty)#>_AssociationChanged(object sender, CollectionChangeEventArgs e)
    {
        <#=code.Escape(navProperty.ToEndMember.GetEntityType())#> elem = e.Element as <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>;
        if (elem != null)
        {
            if (e.Action == CollectionChangeAction.Add)
			{
				this.<#=code.FieldName(navProperty)#>.CollectionChanged -= <#=code.Escape(navProperty)#>Collection_CollectionChanged;
                this.<#=code.FieldName(navProperty)#>.Add(new <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco(elem, DbEntities));
				this.<#=code.FieldName(navProperty)#>.CollectionChanged += <#=code.Escape(navProperty)#>Collection_CollectionChanged;
			}
            else if (e.Action == CollectionChangeAction.Remove)
			{
				this.<#=code.FieldName(navProperty)#>.CollectionChanged -= <#=code.Escape(navProperty)#>Collection_CollectionChanged;
				<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco pocoToRemove = this.<#=code.FieldName(navProperty)#>.Where(i => i.Context.Equals(elem)).SingleOrDefault();
                this.<#=code.FieldName(navProperty)#>.Remove(pocoToRemove); 
				this.<#=code.FieldName(navProperty)#>.CollectionChanged += <#=code.Escape(navProperty)#>Collection_CollectionChanged;
			}
            else if (e.Action == CollectionChangeAction.Refresh)
            {
				<#=code.FieldName(navProperty)#>.CollectionChanged -= <#=code.Escape(navProperty)#>Collection_CollectionChanged;
                new List<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco>(<#=code.FieldName(navProperty)#>).ForEach(i => <#=code.FieldName(navProperty)#>.Remove(i));
				<#=code.FieldName(navProperty)#>.CollectionChanged += <#=code.Escape(navProperty)#>Collection_CollectionChanged;
 
				IEnumerable<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>> efEntities = DbEntities.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Unchanged | EntityState.Deleted).Where(i => i.Entity is <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>).Select(i => i.Entity).Cast<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>>();
                foreach (var item in efEntities)
                    <#=code.FieldName(navProperty)#>.Add(new <#=code.Escape(navProperty.ToEndMember.GetEntityType())#>Poco(item, DbEntities));
 
				_context.<#=code.Escape(navProperty)#>.AssociationChanged -= <#=code.Escape(navProperty)#>_AssociationChanged;
                _context.<#=code.Escape(navProperty)#>.AssociationChanged += <#=code.Escape(navProperty)#>_AssociationChanged;
            }
        }
    }
 
<#
        }
        else
        {
#>
    <#=PropertyVirtualModifier(Accessibility.ForProperty(navProperty))#> <#=code.Escape(navProperty.ToEndMember.GetEntityType())#> <#=code.Escape(navProperty)#>
    {
<#
            if (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey)
            {
#>
		<#=code.SpaceAfter(Accessibility.ForGetter(navProperty))#>get { return _context.<#=code.Escape(navProperty)#>; } //dfgh2 Type:<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>
        <#=code.SpaceAfter(Accessibility.ForSetter(navProperty))#>set
		{  
			if (!Object.ReferenceEquals(_context.<#=code.Escape(navProperty)#>, value))
            {
				_context.<#=code.Escape(navProperty)#>Reference.AssociationChanged -= <#=code.Escape(navProperty)#>_AssociationChanged;
				_context.<#=code.Escape(navProperty)#> = value;
				_context.<#=code.Escape(navProperty)#>Reference.AssociationChanged += <#=code.Escape(navProperty)#>_AssociationChanged;
				if (PropertyChanged != null)
					PropertyChanged(this, new PropertyChangedEventArgs("<#=code.Escape(navProperty)#>"));
			}
		}
    }
 
	void <#=code.Escape(navProperty)#>_AssociationChanged(object sender, CollectionChangeEventArgs e)
    {
			if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("<#=code.Escape(navProperty)#>"));
	}
<#
            }
            else
            {
#>
        <#=code.SpaceAfter(Accessibility.ForGetter(navProperty))#>get dfgh3;
        <#=code.SpaceAfter(Accessibility.ForSetter(navProperty))#>set;
    }
<#
            }
        }
    }
    region.End();
 
    region.Begin("Association Fixup");
 
 
    region.End();
#>
}
<#
    EndNamespace(namespaceName);
}
 
foreach (ComplexType complex in ItemCollection.GetItems<ComplexType>().OrderBy(e => e.Name))
{
    fileManager.StartNewFile(complex.Name + ".cs");
    BeginNamespace(namespaceName, code);
#>
<#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>
{
<#
    region.Begin("Primitive Properties");
 
    foreach(EdmProperty edmProperty in complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex))
    {
        bool isDefaultValueDefinedInModel = (edmProperty.DefaultValue != null);
#>
 
    <#=Accessibility.ForProperty(edmProperty)#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
<#
        if (isDefaultValueDefinedInModel)
        {
#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get dfgh4{ return <#=code.FieldName(edmProperty)#>; }
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
    }
    private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#><#=code.StringBefore(" = ", code.CreateLiteral(edmProperty.DefaultValue))#>;
<#
        }
        else
        {
#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get dfgh5;
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set;
    }
<#
        }
    }
 
    region.End();
 
    region.Begin("Complex Properties");
 
    foreach(EdmProperty edmProperty in complex.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == complex))
    {
#>
 
    <#=Accessibility.ForProperty(edmProperty)#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get dfgh6{ return <#=code.FieldName(edmProperty)#>; }
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
    }
    private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#> = new <#=code.Escape(edmProperty.TypeUsage)#>();
<#
    }
 
    region.End();
#>
}
<#
    EndNamespace(namespaceName);
}
 
if (!VerifyTypesAreCaseInsensitiveUnique(ItemCollection))
{
    return "";
}
 
fileManager.Process();
 
#>
<#+
void WriteHeader(EntityFrameworkTemplateFileManager fileManager, params string[] extraUsings)
{
    fileManager.StartHeader();
#>
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated from a template written by Chad W. Stoker.
//	   10/18/2011
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
 
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Data;
using System.ComponentModel;
 
<#=String.Join(String.Empty, extraUsings.Select(u => "using " + u + ";" + Environment.NewLine).ToArray())#>
<#+
    fileManager.EndBlock();
}
 
void BeginNamespace(string namespaceName, CodeGenerationTools code)
{
    CodeRegion region = new CodeRegion(this);
    if (!String.IsNullOrEmpty(namespaceName))
    {
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#+
        PushIndent(CodeRegion.GetIndent(1));
    }
}
 
 
void EndNamespace(string namespaceName)
{
    if (!String.IsNullOrEmpty(namespaceName))
    {
        PopIndent();
#>
}
<#+
    }
}
 
bool IsReadWriteAccessibleProperty(EdmMember member)
{
    string setter = Accessibility.ForWriteOnlyProperty(member);
    string getter = Accessibility.ForReadOnlyProperty(member);
 
    return getter != "private" && getter != "protected" && setter != "private" && setter != "protected";
}
 
string PropertyVirtualModifier(string accessibility)
{
    return accessibility + (accessibility != "private" ? " virtual" : "");
}
 
void WriteCustomObservableCollection()
{
#>
// An System.Collections.ObjectModel.ObservableCollection that raises
// individual item removal notifications on clear and prevents adding duplicates.
public class FixupCollection<T> : ObservableCollection<T>
{
    protected override void ClearItems()
    {
        new List<T>(this).ForEach(t => Remove(t));
    }
 
    protected override void InsertItem(int index, T item)
    {
        if (!this.Contains(item))
        {
            base.InsertItem(index, item);
        }
    }
}
<#+
}
 
bool VerifyTypesAreCaseInsensitiveUnique(EdmItemCollection itemCollection)
{
    Dictionary<string, bool> alreadySeen = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
    foreach(StructuralType type in itemCollection.GetItems<StructuralType>())
    {
        if (!(type is EntityType || type is ComplexType))
        {
            continue;
        }
 
        if (alreadySeen.ContainsKey(type.FullName))
        {
            Error(String.Format(CultureInfo.CurrentCulture, "This template does not support types that differ only by case, the types {0} are not supported", type.FullName));
            return false;
        }
        else
        {
            alreadySeen.Add(type.FullName, true);
        }
 
    }
 
    return true;
}
#>