SpineInfoParser.ttinclude

<#@ import namespace="System" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.Collections.Generic" #> 
<#@ assembly name="EnvDTE" #>
<#@ import namespace="EnvDTE" #>
<#+
    private string FilePath 
    {
        get
        {
            
            IServiceProvider serviceProvider = (IServiceProvider)this.Host;
            DTE dte = serviceProvider.GetService(typeof(DTE)) as DTE; 
            string path = new FileInfo(dte.Solution.FullName).Directory.FullName;
            path = Path.Combine(path,"SpineDataInfo.txt");
            return path;
        }
    }
    private StringReader GetStringReader()
    {
        return new StringReader(File.ReadAllText(FilePath));
    }
    
    private List<string> GetAllLines()
    {
        var stringReader = GetStringReader();
        var lines = new List<string>();
        var line = stringReader.ReadLine();
        lines.Add(line);
        while (line != null)
        {
            line = stringReader.ReadLine();
            if(!string.IsNullOrEmpty(line))
                lines.Add(line.Replace("\"",""));
        }
        stringReader.Close();
        return lines;
    }

    public string MakeFirstCharUpper(string str)
    {
        var firstChar = str.Substring(0, 1).ToUpper();
        var result = str.Substring(1);
        return firstChar + result;
    }

    /// <summary>
    /// enumName
    ///     enumValues
    /// </summary>
    public Dictionary<string, List<string>> GetAllEnums(bool includeEditor)
    {
        var enums = new Dictionary<string, List<string>>();
        var categories = GetAllClasses(true,includeEditor);
        var prefix = GetPrefix();
        var postfix= GetEnumPostfix();

        foreach (var category in categories)
        {
            var categoryName = category.Key.Item1;
            foreach (var tuple in category.Value)
            {
                if(!tuple.Item1.Contains("enum"))
                    continue;
                    
                var enumName = GetEnumType(categoryName,prefix,postfix,tuple.Item2);
                var enumValues =                                             //vnizu tabulyaciya
                    tuple.Item1.Replace("enum[", "").Replace("]", "").Replace("	","").Split(',').Select(e => MakeFirstCharUpper(e));
                enums.Add(enumName,enumValues.ToList());
            }
        }
        return enums;
    }

    private string GetEnumType(string categoryName, string prefix, string postfix, string propName)
    {
        var enumName = prefix + categoryName + MakeFirstCharUpper(propName) + postfix;
        return enumName;        
    }

    /// <summary>
    ///     objectName
    ///         prop - defaultValue
    /// </summary>
    public Dictionary<Tuple<string,string>, List<Tuple<string, string, string>>> GetAllClasses(bool raw,bool includeEditor)
    {
        var lines = GetAllLines();
            
        var categoriesRaw = new Dictionary<Tuple<string,string>,List<string>>();
        var categoryRaw = new List<string>();
        var prefix = "";
        var postfix = "";
        var postfixEnum = "";
        if(!raw)
        {
            prefix = GetPrefix();
            postfix = GetPostfix();
            postfixEnum = GetEnumPostfix();
        }

        foreach (var line in lines)
        {
            if(string.IsNullOrEmpty(line))
                continue;
            var lineFormated = line.Replace(" ", "").Replace("	","");//remove whiteSpace

            if (lineFormated.Contains("={") || lineFormated.Contains("=<")) //is begin of data
            {
                if(lineFormated.Contains("={"))
                {
                    var categoryName = lineFormated.Substring(0, lineFormated.IndexOf("={"));
                    categoriesRaw.Add(new Tuple<string,string>(categoryName,""), categoryRaw);
                }
                else
                {
                    var categoryName = lineFormated.Substring(0, lineFormated.IndexOf("=<"));
                    var firstIndex = lineFormated.IndexOf("=<")+2;
                    var count = lineFormated.IndexOf(">") - firstIndex;
                    var baseType = lineFormated.Substring(firstIndex,count);
                    categoriesRaw.Add(new Tuple<string,string>(categoryName,baseType), categoryRaw);
                    categoryRaw = new List<string>();
                }         
            }
            else if (lineFormated.Contains("}")) //is end of data
            {
                categoryRaw = new List<string>();
            }
            else // props
            {
                if(lineFormated.Contains(":"))
                    categoryRaw.Add(lineFormated);
            }
        }
        var categories = new Dictionary<Tuple<string,string>, List<Tuple<string,string,string>>>();
        foreach (var category in categoriesRaw)
        {
            var categoryName = category.Key.Item1;
            if(categoryName.Contains("Settings") && !raw)
                continue;
            
            var categoryProps = new List<Tuple<string,string,string>>();
            var categoryNameNotRaw = categoryName;
            var baseTypeNotRaw = category.Key.Item2;
            if(!raw)
            {
                categoryNameNotRaw = prefix+categoryNameNotRaw+postfix;
                if(!string.IsNullOrEmpty(baseTypeNotRaw))
                    baseTypeNotRaw = ApplyBaseTypes(prefix,postfix,postfixEnum,baseTypeNotRaw,categoryName,categoryName);
            }
                

            categories.Add(new Tuple<string,string>(categoryNameNotRaw,baseTypeNotRaw), categoryProps);
            foreach (var prop in category.Value)
            {
                var propFormated = prop.Replace(":", "#").Replace("=", "#").Split('#');
                var propType = propFormated[0];
                var propName = propFormated[1];
                var isString = propType.Contains("string");

                if(propName.Contains("(editor)") && !includeEditor)
                    continue;
                    
                propName = propName.Replace("(editor)","");    
                if(!raw)
                    propType = ApplyBaseType(prefix,postfix,postfixEnum,propType,propName,categoryName);
                
                
                categoryProps.Add(new Tuple<string, string, string>(propType, propName, (propFormated.Length > 2 ? string.Format((isString?"\"{0}\"":"{0}"),propFormated[2]) : null)));
            }
        }
        return categories;
    }


    public string ApplyPrefixAndPostfix(string str)
    {
        if(str.Contains("[]"))
            return GetPrefix()+str.Replace("[]","")+GetPostfix()+"[]";
        
        return GetPrefix()+str+GetPostfix()+"[]";
    }

    private string ApplyBaseTypes(string prefix,string postfix,string postfixEnum,string str,string propName,string categoryName)
    {
        str = str.Replace(" ","");
        var first = ApplyBaseType(prefix,postfix,postfixEnum,str.Substring(0,str.IndexOf(",")),propName,categoryName);
        var second = ApplyBaseType(prefix,postfix,postfixEnum,str.Substring(str.IndexOf(",")+1),propName,categoryName);
        return first+","+second;
    }

    private string ApplyBaseType(string prefix,string postfix,string postfixEnum,string propType,string propName,string categoryName)
    {
         if(propType != ("int") 
            && propType != ("float") 
            && propType != ("bool") 
            && propType != ("string") 
            && propType != ("Color") 
            && propType != ("int[]") 
            && propType != ("float[]") 
            && propType != ("bool[]") 
            && propType != ("string[]") 
            && propType != ("Color[]")             
            && !propType.StartsWith("enum"))
        {
            if(propType.Contains("[]") && !propType.Contains("enum"))
                propType = prefix + propType.Replace("[]","") + postfix + "[]";
            else 
                propType = prefix + propType + postfix;
        }  else if(propType.Contains("enum"))
        {
            propType = GetEnumType(categoryName,prefix,postfixEnum,propName);
        }else{
            
        }
        return propType;
    }

    private string GetPrefix()
    {
        var categories = GetAllClasses(true,true);
        
        if(categories.Any(e=>e.Key.Item1 == "Settings"))
        {
            var category = categories.FirstOrDefault(e=>e.Key.Item1 == "Settings");
            return category.Value.FirstOrDefault(e => e.Item2 == "Prefix").Item3.Replace("\"","");
        }
        return "";
    }

    private string GetPostfix()
    {
        var categories = GetAllClasses(true,true);
        if(categories.Any(e=>e.Key.Item1 == "Settings"))
        {
            var category = categories.FirstOrDefault(e=>e.Key.Item1 == "Settings");
            return category.Value.FirstOrDefault(e => e.Item2 == "Postfix").Item3.Replace("\"","");
        }
        return "";
    }

    private string GetEnumPostfix()
    {
        var categories = GetAllClasses(true,true);
        if(categories.Any(e=>e.Key.Item1 == "Settings"))
        {
            var category = categories.FirstOrDefault(e=>e.Key.Item1 == "Settings");        
            return category.Value.FirstOrDefault(e => e.Item2 == "EnumPostfix").Item3.Replace("\"","");
        }
        return "";
    }
 #>