public Player GetByQuery(string name)
    {
        var SearchResultUrl = "http://svenskfotboll.se/sok/?q=" + name + "&search-type=0";
            var SearchDOM = new DOM(SearchResultUrl);
            if (SearchDOM != null)
            {

                var PlayerUrls = Regex.Match(SearchDOM.Html, "<a href=\"(http://svenskfotboll.se/.*/person/.playerid=\\d*)\"");

                if (PlayerUrls.Success)
                {
                    string PlayerProfileUrl = PlayerUrls.Groups[1].Value;

                    return GetPlayerProfile(PlayerProfileUrl);

                }

            }
            else
            {
                return null;
            }

            return null;
    }

    private Player GetPlayerProfile(string url)
    {
        var Document = new DOM(url);
            Player player = new Player();

            player.Id = Regex.Match(url, "playerid=(\\d*)").Groups[1].Value;
            player.Permalink = url;
            player.Name = Document.DocumentModel.SelectSingleNode("//h1[@class='h']").InnerText;
            player.ImageUrl = "http://svenskfotboll.se" + Document.DocumentModel.SelectSingleNode("//div[@class='player-image']/img/@src").InnerText;

            var TableRows = Document.DocumentModel.SelectNodes("//table[@class='clTblStatBox']//tr");

            player.ShirtNumber = Document.DocumentModel.SelectSingleNode("//table[@class='clTblStatBox']//thead").InnerText;
            player.ShirtNumber = Regex.Match(player.ShirtNumber, "Nr (\\d*)").Groups[1].Value;

            player.BirthDate = TableRows.GetCellValueByFirstColumn("Född:");

            var HeightAndWeight = TableRows.GetCellValueByFirstColumn("Längd/Vikt:");
            if (HeightAndWeight.Contains("/"))
            {
                player.Height = HeightAndWeight.Split('/')[0];
                player.Weight = HeightAndWeight.Split('/')[1];
            }

            player.MotherClub = TableRows.GetCellValueByFirstColumn("Moderklubb:");

            return player;
    }

        public List<Match> ParseMatches(DOM document)
        {
            var matches = new List<Match>();
            try
            {
                var upcomingGamesSection = document.HtmlDoc.DocumentNode.SelectSingleNode("//section[@class='upcoming-games']");
                var matchRows = upcomingGamesSection.SelectNodes("//tr[@data-match-id]");
                var homeTeamNodes = upcomingGamesSection.SelectNodes("//span[@class='team home']");
                var awayTeamNodes = upcomingGamesSection.SelectNodes("//span[@class='team away']");
                var matchDates = upcomingGamesSection.SelectNodes("//span[@class='date-short matchTid']");
                var matchTimes = upcomingGamesSection.SelectNodes("//span[@class='time matchTid']");
                var locations = upcomingGamesSection.SelectNodes("//a[@class='location']");
                for (int i = 0; i < matchRows.Count; i++)
                {
                    var homeTeamNode = homeTeamNodes[i];
                    var homeTeamName = HttpUtility.HtmlDecode(homeTeamNode.InnerHtml);
                    var awayTeamNode = awayTeamNodes[i];
                    var awayTeamName = HttpUtility.HtmlDecode(awayTeamNode.InnerHtml);
                    var matchDate = matchDates[i].InnerText;
                    if (matchDate == "Imorgon")
                    {
                        var tomorrow = DateTime.Now.AddDays(1);
                        matchDate = string.Format("{0}/{1}", tomorrow.Day, tomorrow.Month);
                    }
                    if (matchDate == "Idag")
                    {
                        var today = DateTime.Now;
                        matchDate = string.Format("{0}/{1}", today.Day, today.Month);
                    }
                    var dateParts = matchDate.Split("/".ToCharArray());
                    var dayOfMonth = int.Parse(dateParts[0]);
                    var month = int.Parse(dateParts[1]);
                    var matchTime = matchTimes[i].InnerText;
                    var timeParts = matchTime.Split(":".ToCharArray());
                    var hour = int.Parse(timeParts[0]);
                    var minutes = int.Parse(timeParts[1]);
                    var matchDateComplete = new DateTime(DateTime.Now.Year, month, dayOfMonth, hour, minutes, 0);
                    var location = locations[i].InnerText;
                    matches.Add(Match.CreateNew(matchDateComplete, homeTeamName, awayTeamName, location));
                }
                return matches;

            }
            catch (Exception)
            {
                return matches;
            }
        }

    public List<Match> GetUpcomingMatches(int seriesID)
    {
        List<Match> Upcoming = (List<Match>)Utilities.GetFromCache(seriesID + ":Upcoming");

            if (Upcoming == null)
            {
                Upcoming = new List<Match>();

                DOM Document = new DOM(GetWidgetUrl("cominginleague", seriesID));

                var TableRows = Document.Query("tr");
                char[] querystringSplitChar = { '=' };

                int RowCount = 0;
                foreach (XmlNode Row in TableRows)
                {
                    try
                    {
                        if (RowCount > 2)
                        {
                            var Columns = Row.SelectNodes("td");

                            Match match = new Match();
                            match.Time = DateTime.Parse(Columns.ValueOfIndex(0));
                            match.MatchName = Columns.ValueOfIndex(1);
                            string MatchURI = Columns[1].SelectSingleNode("a").GetAttributeValue("href");
                            match.ID = MatchURI.Split(querystringSplitChar).LastOrDefault().ToString();

                            PopulateMatchDetails(match);
                            Upcoming.Add(match);

                        }
                        RowCount = RowCount + 1;
                    }
                    catch (Exception ex)
                    {

                    }
                }

                Utilities.InsertToCache(seriesID + ":Upcoming", Upcoming);

            }

            return Upcoming;
    }

    public List<TeamResults> GetScoreTable(int seriesID)
    {
        List<TeamResults> ScoreTable = (List<TeamResults>)Utilities.GetFromCache(seriesID + ":Scores");

            if (ScoreTable == null)
            {

                ScoreTable = new List<TeamResults>();

                DOM Document = new DOM(GetWidgetUrl("table", seriesID));

                var TableRows = Document.Query("table//tr");

                int RowCount = 0;
                foreach (XmlNode Row in TableRows)
                {
                    if (RowCount > 2)
                    {
                        var Columns = Row.SelectNodes("td");

                        TeamResults score = new TeamResults();

                        score.TeamName = Columns.ValueOfIndex(0);

                        score.MatchesPlayed = Columns.ValueOfIndex(1);
                        score.MatchesWon = Columns.ValueOfIndex(2);
                        score.MatchesDraw = Columns.ValueOfIndex(3);
                        score.MatchesLost = Columns.ValueOfIndex(4);
                        score.GoalsMadeAndReceived = Columns.ValueOfIndex(5);
                        score.Difference = Columns.ValueOfIndex(6);
                        score.Points = Columns.ValueOfIndex(7);

                        ScoreTable.Add(score);
                    }
                    RowCount = RowCount + 1;
                }
                    Utilities.InsertToCache(seriesID + ":Scores", ScoreTable);
                }

            return ScoreTable;
    }

    public List<Series> GetSeries()
    {
        List<Series> AllSeries = (List<Series>)Utilities.GetFromCache("AllSeries");

            if (AllSeries == null) {
                AllSeries = new List<Series>();
                DOM Document = new DOM("http://www.svenskfotboll.se");
                var Series = Document.Query("select[@id='ftid-stickybar']//option");
                foreach(XmlNode node in Series){
                    Series serie = new Series();
                    serie.ID = int.Parse(node.GetAttributeValue("value"));
                    serie.Name = node.InnerText;
                    AllSeries.Add(serie);
                }

               Utilities.InsertToCache("AllSeries", AllSeries);

            }

            return AllSeries;
    }

 public static bool KhtmlValidAttrName(DOM.DOMString name)
 {
     return (bool) staticInterceptor.Invoke("khtmlValidAttrName#", "khtmlValidAttrName(const DOM::DOMString&)", typeof(bool), typeof(DOM.DOMString), name);
 }

 public virtual short AcceptNode(DOM.Node n)
 {
     return (short) interceptor.Invoke("acceptNode#", "acceptNode(const DOM::Node&)", typeof(short), typeof(DOM.Node), n);
 }

 public HTMLTableElement(DOM.HTMLTableElement other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("HTMLTableElement#", "HTMLTableElement(const DOM::HTMLTableElement&)", typeof(void), typeof(DOM.HTMLTableElement), other);
 }

 /// <remarks>
 ///  see tHead
 ///      </remarks>		<short>    see tHead      </short>
 public void SetTHead(DOM.HTMLTableSectionElement arg1)
 {
     interceptor.Invoke("setTHead#", "setTHead(const DOM::HTMLTableSectionElement&)", typeof(void), typeof(DOM.HTMLTableSectionElement), arg1);
 }

 public HTMLSelectElement(DOM.Node other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("HTMLSelectElement#", "HTMLSelectElement(const DOM::Node&)", typeof(void), typeof(DOM.Node), other);
 }

 public DOMImplementation(DOM.DOMImplementation other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("DOMImplementation#", "DOMImplementation(const DOM::DOMImplementation&)", typeof(void), typeof(DOM.DOMImplementation), other);
 }

 public DocumentFragment(DOM.Node other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("DocumentFragment#", "DocumentFragment(const DOM::Node&)", typeof(void), typeof(DOM.Node), other);
 }

 public AbstractView(DOM.AbstractView other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("AbstractView#", "AbstractView(const DOM::AbstractView&)", typeof(void), typeof(DOM.AbstractView), other);
 }

 /// <remarks>
 ///  Introduced in DOM Level 3
 ///  This method makes available a DOMImplementation's specialized
 ///  interface.
 /// <param> name="feature" The name of the feature requested (case-insensitive)
 /// </param></remarks>		<return> Returns an alternate DOMImplementation which implements
 ///  the specialized APIs of the specified feature, if any, or null
 ///  if there is no alternate DOMImplementation object which implements
 ///  interfaces associated with that feature. Any alternate DOMImplementation
 ///  returned by this method must delegate to the primary core DOMImplementation
 ///  and not return results inconsistent with the primary DOMImplementation.
 ///      </return>
 /// 		<short>    Introduced in DOM Level 3  This method makes available a DOMImplementation's specialized  interface.</short>
 public DOM.DOMImplementation GetInterface(DOM.DOMString feature)
 {
     return (DOM.DOMImplementation) interceptor.Invoke("getInterface#", "getInterface(const DOM::DOMString&) const", typeof(DOM.DOMImplementation), typeof(DOM.DOMString), feature);
 }

 /// <remarks>
 ///  see selectorText
 ///      </remarks>		<short>    see selectorText </short>
 public void SetSelectorText(DOM.DOMString arg1)
 {
     interceptor.Invoke("setSelectorText#", "setSelectorText(const DOM::DOMString&)", typeof(void), typeof(DOM.DOMString), arg1);
 }

 public CSSPageRule(DOM.CSSRule other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("CSSPageRule#", "CSSPageRule(const DOM::CSSRule&)", typeof(void), typeof(DOM.CSSRule), other);
 }

 public WebKitDOMCSSDeclarationStyle GetStyleFromElement(DOM.Element element, string pseudoElement = "") // this feature has not been implemented yet
 {
     return new WebKitDOMCSSDeclarationStyle(browser.WebView.computedStyleForElement((IDOMElement)element.GetWebKitObject(), pseudoElement));
 }

 /// <remarks>
 ///  Introduced in DOM Level 2
 ///  Creates an empty DocumentType node. Entity declarations and notations
 ///  are not made available. Entity reference expansions and default
 ///  attribute additions do not occur. It is expected that a future version
 ///  of the DOM will provide a way for populating a DocumentType.
 ///  HTML-only DOM implementations do not need to implement this method.
 /// <param> name="qualifiedName" The qualified name of the document type to be
 ///  created.
 /// </param><param> name="publicId" The external subset public identifier.
 /// </param><param> name="systemId" The external subset system identifier.
 /// </param> NAMESPACE_ERR: Raised if the qualifiedName is malformed.
 ///      </remarks>		<return> A new DocumentType node with Node.ownerDocument set to null.
 /// </return>
 /// 		<short>    Introduced in DOM Level 2 </short>
 public DOM.DocumentType CreateDocumentType(DOM.DOMString qualifiedName, DOM.DOMString publicId, DOM.DOMString systemId)
 {
     return (DOM.DocumentType) interceptor.Invoke("createDocumentType###", "createDocumentType(const DOM::DOMString&, const DOM::DOMString&, const DOM::DOMString&)", typeof(DOM.DocumentType), typeof(DOM.DOMString), qualifiedName, typeof(DOM.DOMString), publicId, typeof(DOM.DOMString), systemId);
 }

 /// <remarks>
 ///  Introduced in DOM Level 2
 ///  Creates an XML Document object of the specified type with its document
 ///  element. HTML-only DOM implementations do not need to implement this
 ///  method.
 /// <param> name="namespaceURI" The namespace URI of the document element to create.
 /// </param><param> name="qualifiedName" The qualified name of the document element to be
 ///  created.
 /// </param><param> name="doctype" The type of document to be created or null. When doctype
 ///  is not null, its Node.ownerDocument attribute is set to the document
 ///  being created.
 /// </param> NAMESPACE_ERR: Raised if the qualifiedName is malformed, if the
 ///  qualifiedName has a prefix and the namespaceURI is null, or if the
 ///  qualifiedName has a prefix that is "xml" and the namespaceURI is
 ///  different from "http://www.w3.org/XML/1998/namespace" [Namespaces].
 ///  WRONG_DOCUMENT_ERR: Raised if doctype has already been used with a
 ///  different document or was created from a different implementation.
 ///      </remarks>		<return> A new Document object.
 /// </return>
 /// 		<short>    Introduced in DOM Level 2 </short>
 public DOM.Document CreateDocument(DOM.DOMString namespaceURI, DOM.DOMString qualifiedName, DOM.DocumentType doctype)
 {
     return (DOM.Document) interceptor.Invoke("createDocument###", "createDocument(const DOM::DOMString&, const DOM::DOMString&, const DOM::DocumentType&)", typeof(DOM.Document), typeof(DOM.DOMString), namespaceURI, typeof(DOM.DOMString), qualifiedName, typeof(DOM.DocumentType), doctype);
 }