public async Task <MetadataResult <Person> > GetMetadata(PersonLookupInfo info, CancellationToken cancellationToken)
        {
            var result = new MetadataResult <Person>()
            {
                HasMetadata = false,
                Item        = new Person(),
            };

            if (info == null)
            {
                return(result);
            }

            info.ProviderIds.TryGetValue(this.Name, out var curID);

            if (string.IsNullOrEmpty(curID))
            {
                var searchResults = await this.GetSearchResults(info, cancellationToken).ConfigureAwait(false);

                if (searchResults.Any())
                {
                    searchResults.First().ProviderIds.TryGetValue(this.Name, out curID);
                }
            }

            if (string.IsNullOrEmpty(curID))
            {
                return(result);
            }

            try
            {
                result = await MetadataAPI.PeopleUpdate(curID, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                Logger.Error($"Actor Update error: \"{e}\"");
            }

            if (result.HasMetadata)
            {
                result.Item.ProviderIds.Add(Plugin.Instance.Name, curID);

                if (result.Item.PremiereDate.HasValue)
                {
                    result.Item.ProductionYear = result.Item.PremiereDate.Value.Year;
                }
            }

            return(result);
        }
        public async Task <IEnumerable <RemoteSearchResult> > GetSearchResults(PersonLookupInfo searchInfo, CancellationToken cancellationToken)
        {
            var result = new List <RemoteSearchResult>();

            if (searchInfo == null)
            {
                return(result);
            }

            if (searchInfo.ProviderIds.TryGetValue(this.Name, out var curID) && !string.IsNullOrEmpty(curID))
            {
                var actorData = new MetadataResult <Person>()
                {
                    HasMetadata = false,
                    Item        = new Person(),
                };

                IEnumerable <RemoteImageInfo> sceneImages = new List <RemoteImageInfo>();

                try
                {
                    actorData = await MetadataAPI.PeopleUpdate(curID, cancellationToken).ConfigureAwait(false);
                }
                catch (Exception e)
                {
                    Logger.Error($"Update error: \"{e}\"");
                }

                try
                {
                    sceneImages = await MetadataAPI.PeopleImages(curID, cancellationToken).ConfigureAwait(false);
                }
                catch (Exception e)
                {
                    Logger.Error($"GetImages error: \"{e}\"");
                }

                if (actorData.HasMetadata)
                {
                    result.Add(new RemoteSearchResult
                    {
                        ProviderIds  = { { Plugin.Instance.Name, curID } },
                        Name         = actorData.Item.ExternalId,
                        ImageUrl     = sceneImages?.Where(o => o.Type == ImageType.Primary).FirstOrDefault()?.Url,
                        PremiereDate = actorData.Item.PremiereDate,
                    });
                }
            }

            if (searchInfo.ProviderIds.Any(o => !string.IsNullOrEmpty(o.Value)))
            {
                return(result);
            }

            try
            {
                result = await MetadataAPI.PeopleSearch(searchInfo.Name, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                Logger.Error($"Actor Search error: \"{e}\"");
            }

            return(result);
        }