public MMAAlbumDataWriter(EMParseAlbumPage parsedAlbumPage)
        {
            // get band data
            country_ = parsedAlbumPage.Country;
            genre_   = parsedAlbumPage.Genre;

            // get album data
            bandName_        = parsedAlbumPage.Band;
            title_           = parsedAlbumPage.Title;
            type_            = parsedAlbumPage.Type;
            year_            = parsedAlbumPage.Year;
            releaseDate_     = parsedAlbumPage.ReleaseDate;
            format_          = parsedAlbumPage.Format;
            label_           = parsedAlbumPage.Label;
            catalogId_       = parsedAlbumPage.CatalogId;
            limitation_      = parsedAlbumPage.Limitation;
            info_            = parsedAlbumPage.Info;
            songs_           = parsedAlbumPage.Songs;
            durations_       = parsedAlbumPage.Durations;
            discsTotalTimes_ = parsedAlbumPage.DiscsTotalTimes;
            lineup_          = parsedAlbumPage.Lineup;
            coverURL_        = parsedAlbumPage.CoverURL;
            albumURL_        = parsedAlbumPage.AlbumURL;

            altVersions_ = new List <AlternateVersion>();

            if (String.IsNullOrEmpty(title_))
            {
                Tools.LogEvent("      Cannot get album title, skipping...");
                return;
            }


            if (String.IsNullOrEmpty(coverURL_))
            {
                Tools.LogEvent("      Cannot get cover image of album \'" + bandName_ + " (" + country_ + ")" + " - " + title_ + "\' (" + year_ + ")");
            }
        }
        private void processBandPage(string band, string urlBand, List <string> existingAlbumsNamesYears)
        {
            // parse band page albums
            string sourceHTMLBandPage = Tools.GetWebPageSourceHTML(urlBand);

            if (String.IsNullOrEmpty(sourceHTMLBandPage))
            {
                Tools.LogEvent("   Page not found for " + band);
                return;
            }
            EMParseBandPage bandPage = new EMParseBandPage(sourceHTMLBandPage);

            if (bandPage.AlbumsURLs == null)
            {
                // parse error or several bands with the same name, skip
                Tools.LogEvent("   Check page for " + band + ". May contain several bands with the same name.");
                return;
            }

            string country = bandPage.Country;

            int    nbFoundAlbums = bandPage.AlbumsURLs.Count;
            string logText       = downloadNewAlbumsOnly_ ?
                                   "   " + nbFoundAlbums + " new album(s) found for " + band + " (" + country + ")" :
                                   "   " + nbFoundAlbums + " album(s) found for " + band + " (" + country + ")";

            Tools.LogEvent(logText);

            // get number of albums
            int nbAlbums = 0; // default

            if (bandPage != null)
            {
                nbAlbums = bandPage.AlbumsURLs.Count;
            }

            // parse band albums
            int indexAlbum = 0;

            foreach (string albumURL in bandPage.AlbumsURLs)
            {
                sendProcessAlbumParams(band, indexAlbum, nbAlbums);

                string albumName = bandPage.AlbumsNames[indexAlbum];
                string albumYear = bandPage.AlbumsYears[indexAlbum];
                string albumType = bandPage.AlbumsTypes[indexAlbum];

                // check if album already exists
                if (downloadNewAlbumsOnly_ && existingAlbumsNamesYears.Count > 0)
                {
                    bool   exists        = false;
                    string albumNameYear = albumName + "_" + albumYear;
                    foreach (string existingAlbumNameYear in existingAlbumsNamesYears)
                    {
                        if (String.Compare(albumNameYear, existingAlbumNameYear, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            exists = true;
                            break;
                        }
                    }

                    // if album already exists, skip
                    if (exists)
                    {
                        Tools.LogEvent("      Album \'" + band + " (" + country + ")" + " - " + albumName + "\' (" + albumYear + ")" + " already exists");
                        indexAlbum++;
                        continue;
                    }
                }

                // check if album data is already downloaded
                {
                    string downloadFilePath = Tools.DownloadFilePath(band, albumName, albumYear, albumType);
                    bool   infoDownloaded   = File.Exists(System.IO.Path.Combine(downloadFilePath + ".txt"));
                    bool   coverDownloaded  = File.Exists(System.IO.Path.Combine(downloadFilePath + ".jpg"));

                    // if album data already downloaded, skip
                    if (infoDownloaded && coverDownloaded)
                    {
                        Tools.LogEvent("      Album \'" + band + " (" + country + ")" + " - " + albumName + "\' (" + albumYear + ")" + " already downloaded");
                        indexAlbum++;
                        continue;
                    }
                }

                // parse album page
                string sourceHTMLAlbumPage = Tools.GetWebPageSourceHTML(albumURL);
                Tools.LogEvent("      Processing album \'" + band + " (" + country + ")" + " - " + albumName + "\' (" + albumYear + ")");
                EMParseAlbumPage page = new EMParseAlbumPage(sourceHTMLAlbumPage, country, bandPage.Genre, albumURL);

                // for debug purposes only

                /*
                 * //string testAlbumURL = "https://www.metal-archives.com/albums/Killswitch_Engage/Incarnate/558828";
                 * //string testAlbumURL = "https://www.metal-archives.com/albums/Killswitch_Engage/Incarnate/568298";
                 * //string testAlbumURL = "https://www.metal-archives.com/albums/Killswitch_Engage/Killswitch_Engage/237410";
                 * string testAlbumURL = "https://www.metal-archives.com/albums/Ad_Baculum/Blackness_Doctrine/317809";
                 * string sourceHTMLAlbumPage = Tools.GetWebPageSourceHTML(testAlbumURL);
                 * EMParseAlbumPage page = new EMParseAlbumPage(sourceHTMLAlbumPage, country, bandPage.Genre, testAlbumURL);
                 */

                MMAAlbumDataWriter writer = new MMAAlbumDataWriter(page);

                // handle alternate versions if existing
                int nbAltVersions = (page.AltVersionsURLs == null) ? 0 : page.AltVersionsURLs.Count;
                if (nbAltVersions > 0)
                {
                    Tools.LogEvent("         " + nbAltVersions.ToString() + " alternate version(s) found for \'" + band + " (" + country + ")" + " - " + albumName + "\' (" + albumYear + ")");

                    foreach (string url in page.AltVersionsURLs)
                    {
                        string           sourceHTMLAlbumPageAlt = Tools.GetWebPageSourceHTML(url);
                        EMParseAlbumPage pageAlt = new EMParseAlbumPage(sourceHTMLAlbumPageAlt, country, bandPage.Genre, url);

                        // add alternate version data
                        writer.AddAlternateVersion(pageAlt.Version, pageAlt.Year, pageAlt.ReleaseDate, pageAlt.Format, pageAlt.Label, pageAlt.CatalogId, pageAlt.Limitation, pageAlt.Info, pageAlt.Songs, pageAlt.Durations, pageAlt.DiscsTotalTimes);
                    }
                }

                // write album data
                writer.WriteAlbumData();

                nbNewAlbumsProcessed_++;
                indexAlbum++;
            }
        }