/// <summary>
 /// Checks if the node is castable to another node of a given tag type.
 /// </summary>
 /// <param name="type">An NBT tag type.</param>
 /// <returns>Status indicating whether this object could be cast to a node type represented by the given tag type.</returns>
 public override bool IsCastableTo (TagType type)
 {
     return (type == TagType.TAG_BYTE ||
         type == TagType.TAG_SHORT ||
         type == TagType.TAG_INT ||
         type == TagType.TAG_LONG);
 }

 public NXPTag(TagType type)
 {
     tag = new Tag();
     tag.Type = type;
     password = new byte[4] { 0, 0, 0, 0 };
     retries = 1;
 }

 /// <summary>
 /// Gets the next node after the start index
 /// </summary>
 /// <param name="code">The code.</param>
 /// <param name="startIndex">The index from which to start searching.</param>
 /// <param name="tagType">Returns next tag type</param>
 /// <param name="previousTag">The previous tag in the stack.</param>
 /// <param name="isParseContent">If the content of the last opening node should be parsed. In Html all the content is parsed.</param>        
 protected override SyntaxNode GetNextNode(string code, ref int startIndex, out TagType tagType, Tag previousTag, bool isParseContent)
 {
     string currentSubstring = code.Substring(startIndex);
     //in the regex I won't work with h1, h2... and such tags!
     string regexPattern = previousTag == null || isParseContent ? @"</?[a-zA-Z]+[^<>]*/?>" : @"<" + previousTag.CloseTag + @">";
     Match tag = Regex.Match(currentSubstring, regexPattern);
     Tag registeredTag = null;
     tagType = TagType.Open; //we just set it here and when needed will do it later
     while (tag.Success && (registeredTag = GetTagByValue(tag.Value)) == null)//getting tags, but they are not registered.
     {
         tag = tag.NextMatch();
     }
     if (!tag.Success) //didn't find a registered tag until the end - return everything left as a text node
     {
         startIndex += currentSubstring.Length;
         return new TextSyntaxNode(currentSubstring);
     }
     if (tag.Index == 0) //if the string given to the matcher was something like '<strong>...'
     {
         if (tag.Value.StartsWith("</"))
         {
             tagType = TagType.Close;
         }
         else if (tag.Value.EndsWith("/>"))
         {
             tagType = TagType.SelfClose;
         }
         startIndex += tag.Value.Length;
         return new HtmlSyntaxNode(registeredTag as HtmlTag, tag.Value);
     }
     //there has been some text before the tag that I found...
     startIndex += tag.Index; //move the start index for the other iterations
     return new TextSyntaxNode(currentSubstring.Substring(0, tag.Index));
 }

 public override bool CanCreateTag(TagType type)
 {
     if (Tag.Count > 0)
         return Tag.ValueType == type;
     else
         return Enum.IsDefined(typeof(TagType), type) && type != TagType.TAG_END;
 }

    protected ITag ReadTag(ReadTagOptions options, TagType defaultTagType)
    {
      ITag result;
      TagType type;

      this.InitializeReader();

      type = this.ReadTagType(defaultTagType);
      result = TagFactory.CreateTag(type);

      if ((options & ReadTagOptions.IgnoreName) == 0)
      {
        string name;

        name = _reader.GetAttribute("name");
        if (string.IsNullOrEmpty(name))
        {
          name = _reader.Name;
        }

        result.Name = name;
      }

      if ((options & ReadTagOptions.IgnoreValue) == 0)
      {
        result.Value = this.ReadTagValue(result);
      }

      return result;
    }

 public string this[TagType type]
 {
     get { return GetId3Data()[type]; }
     set
     {
         switch (type)
         {
             case TagType.Artist:
                 Artist = value;
                 break;
             case TagType.Id:
                 TrackId = value;
                 break;
             case TagType.Title:
                 Title = value;
                 break;
             case TagType.Album:
                 Album = value;
                 break;
             case TagType.Genre:
                 Genre = value;
                 break;
             case TagType.Year:
                 Year = value;
                 break;
             case TagType.Comment:
                 Comment = value;
                 break;
             default:
                 throw new ArgumentOutOfRangeException(type.ToString(), type, null);
         }
     }
 }

        //TODO: move to separate class {READY}
        public UserData GetInfoFromUser(TagType tag, Diff diff, IMp3File file, ICommunication communication)
        {
            communication.SendMessage($"File: {file.FilePath}");
            communication.SendMessage($"There is a problem with tag \"{tag}\". ");
            communication.SendMessage(
                $"You can enter tag from: \n\t1) File name (Data: \"{diff.FileNameValue}\"), \n\t2) Mp3 Tags (Data: \"{diff.TagValue}\"), \n\t3) Manual");

            while (true)
            {
                communication.SendMessage("Your choise (number): ");
                SyncActions inputData;
                var choiseCorrect = Enum.TryParse(communication.GetResponse(), out inputData);
                if (!choiseCorrect)
                {
                    communication.SendMessage("Wrong input!");
                    communication.SendMessage("You sholud enter number with action!");
                    continue;
                }

                switch (inputData)
                {
                    case SyncActions.FromFileName:
                        return new UserData(inputData, diff.FileNameValue);
                    case SyncActions.FromTags:
                        return new UserData(inputData, diff.TagValue);
                    case SyncActions.Manual:
                        communication.SendMessage("Enter text for tag \"" + tag + "\"");
                        return new UserData(inputData, communication.GetResponse());
                }
            }
        }

 public OpenTag(TagType tag, IEnumerable<IExpression> arguments) {
     _Tag = tag;
     if (arguments == null)
         _Arguments = new IExpression[0];
     else
         _Arguments = arguments.ToArray();
 }

 /// <summary>
 /// Gets the next node after the start index.
 /// </summary>
 /// <param name="code">The code.</param>
 /// <param name="startIndex">The index from which to start searching.</param>
 /// <param name="tagType">Returns the next tag type</param>
 /// <param name="previousTag">The previous tag in the stack.</param>
 /// <param name="isParseContent">If the content of the last opening node should be parsed.</param>
 /// <returns></returns>
 protected override SyntaxNode GetNextNode(string code, ref int startIndex, out TagType tagType, Tag previousTag, bool isParseContent)
 {
     string currentSubstring = code.Substring(startIndex);
     string regexPattern = previousTag == null || isParseContent ? @"\[/?[a-z*][a-z0-9]*(=[^\[\]\n\r\v\f]+)?\]" : @"\[" + previousTag.CloseTag + @"\]"; //the close tag has /
     Match tag = Regex.Match(currentSubstring, regexPattern);
     Tag registeredTag = null;
     tagType = TagType.Open; //we just set it here and when needed will do it later
     while (tag.Success && (registeredTag = GetTagByValue(tag.Value)) == null)//getting tags, but they are not registered.
     {
         tag = tag.NextMatch();
     }
     if (!tag.Success) //didn't find a registered tag until the end - return everything left as a text node
     {
         startIndex += currentSubstring.Length;
         return new TextSyntaxNode(currentSubstring);
     }
     if (tag.Index == 0) //if the string given to the matcher was something like '[b]...'
     {
         if (tag.Value.StartsWith("[/")) tagType = TagType.Close;
         startIndex += tag.Value.Length;
         return new BBCodeSyntaxNode(registeredTag as BBTag, tag.Value);
     }
     //there has been some text before the tag that I found...
     startIndex += tag.Index; //move the start index for the other iterations
     return new TextSyntaxNode(currentSubstring.Substring(0, tag.Index));
 }

        public TagData(string name, Hash sha1, TagType tagType)
        {
            Verify.Argument.IsNeitherNullNorWhitespace(name, "name");

            _name    = name;
            _sha1    = sha1;
            _tagType = tagType;
        }

        public static TagsManager CreateFormFile(String file, TagType type = TagType.Automatic, bool parseTags = true)
        {
            var handle = TagsLibCoreModule.CreateFunction.Delegate();
            var result = new TagsManager(handle);

            TagsLibCoreModule.LoadTagsFunction.Delegate(handle, file, type, parseTags);

            return result;
        }

 public IfElement(TagType tag, INode condition, INode trueValue, INode falseValue)
 {
     if (condition == null)
         throw new ArgumentNullException("condition");
     _Tag = tag;
     _Condition = condition;
     _TrueValue = trueValue;
     _FalseValue = falseValue;
 }

        public static TagsManager CreateFormMemory(IntPtr memory, ulong size, TagType type = TagType.Automatic, bool parseTags = true)
        {
            var handle = TagsLibCoreModule.CreateFunction.Delegate();
            var result = new TagsManager(handle);

            TagsLibCoreModule.LoadTagsFormMemoryFunction.Delegate(handle, memory, size, type, parseTags);

            return result;
        }

 public SwitchElement(TagType tag, INode caseSwitch, IDictionary<int, INode> cases)
 {
     if (caseSwitch == null)
         throw new ArgumentNullException("caseSwitch");
     if (cases == null)
         throw new ArgumentNullException("cases");
     _Tag = tag;
     _CaseSwitch = caseSwitch;
     _Cases = new ReadOnlyDictionary<int, INode>(cases);
 }

        public CreateNodeForm(TagType tagType, bool hasName)
        {
            InitializeComponent();

            _type = tagType;
            _hasName = hasName;

            SetNameBoxState();
            SetSizeBoxState();
        }

		public override TagCollection GetUserTags(int userID, TagType type)
		{
			switch (type)
			{
				case TagType.Blog:
					return GetUserBlogTags(userID);

				default:
					return new TagCollection();
			}
		}

 public Tag(string name, TagType type, Guid owner, FileEntry entry)
 {
     TagName = name;
     TagType = type;
     Owner = owner;
     if (entry != null)
     {
         EntryId = entry.ID;
         EntryType = entry is File ? FileEntryType.File : FileEntryType.Folder;
     }
 }

        public override bool CreateNode(TagType type)
        {
            if (!CanCreateTag(type))
                return false;

            if (Tag.Count == 0) {
                Tag.ChangeValueType(type);
            }

            AppendTag(TagDataNode.DefaultTag(type));
            return true;
        }

        public IEnumerable<Tag> GetTags(Guid owner, TagType tagType)
        {
            var q = Query("files_tag t")
                .InnerJoin("files_tag_link l", Exp.EqColumns("l.tag_id", "t.id"))
                .Select("t.name", "t.flag", "t.owner", "entry_id", "entry_type", "t.id")
                .Where("l.tenant_id", TenantID)
                .Where("t.owner", owner.ToString())
                .Where("t.flag", (int)tagType);

            return SelectTagByQuery(q);

        }

        public IEnumerable<Tag> GetTags(object entryID, FileEntryType entryType, TagType tagType)
        {
            var q = Query("files_tag t")
                .InnerJoin("files_tag_link l", Exp.EqColumns("l.tag_id", "t.id"))
                .Select("t.name", "t.flag", "t.owner", "entry_id", "entry_type", "tag_count", "t.id")
                .Where("l.tenant_id", TenantID)
                .Where("l.entry_type", (int) entryType)
                .Where(Exp.Eq("l.entry_id", MappingID(entryID)))
                .Where("t.flag", (int) tagType);

            return SelectTagByQuery(q);
        }