<?php

use Illuminate\Console\Command;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputArgument;
use Illuminate\Support\Facades\File;
use Entities\Album;
use Entities\Image;
use Entities\Genre;
use Entities\User;
use Entities\Track;
use Commands\UploadTrackCommand;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Carbon\Carbon;

require_once(app_path() . '/library/getid3/getid3/getid3.php');


class ImportMLPMA extends Command {

	/**
	 * The console command name.
	 *
	 * @var string
	 */
	protected $name = 'mlpma:import';

	/**
	 * The console command description.
	 *
	 * @var string
	 */
	protected $description = 'Imports the MLP Music Archive';

	/**
	 * File extensions to ignore when importing the archive.
	 *
	 * @var array
	 */
	protected $ignoredExtensions = ['db', 'jpg', 'png'];

	/**
	 * Used to stop the import process when a SIGINT is received.
	 *
	 * @var bool
	 */
	protected $isInterrupted = false;

	/**
	 * A counter for the number of processed tracks.
	 *
	 * @var int
	 */
	protected $currentFile;

	/**
	 * Create a new command instance.
	 *
	 * @return void
	 */
	public function __construct()
	{
		parent::__construct();
	}

	public function handleInterrupt($signo) {
		$this->error('Import aborted!');
		$this->error('Resume it from here using: --startAt='.$this->currentFile);
		$this->isInterrupted = true;
	}

	/**
	 * Execute the console command.
	 *
	 * @return void
	 */
	public function fire()
	{
		pcntl_signal(SIGINT, [$this, 'handleInterrupt']);

		$mlpmaPath = Config::get('app.files_directory').'mlpma';
		$tmpPath = Config::get('app.files_directory').'tmp';

		if (!File::exists($tmpPath)) {
			File::makeDirectory($tmpPath);
		}

		$UNKNOWN_GENRE = Genre::firstOrCreate([
			'name' => 'Unknown',
			'slug' => 'unknown'
		]);

		$this->comment('Enumerating MLP Music Archive source files...');
		$files = File::allFiles($mlpmaPath);
		$this->info(sizeof($files).' files found!');

		$this->comment('Enumerating artists...');
		$artists = File::directories($mlpmaPath);
		$this->info(sizeof($artists).' artists found!');

		$this->comment('Importing tracks...');

		$totalFiles = sizeof($files);

		$fileToStartAt = (int) $this->option('startAt') - 1;
		$this->comment("Skipping $fileToStartAt files...".PHP_EOL);

		$files = array_slice($files, $fileToStartAt);
		$this->currentFile = $fileToStartAt;

		foreach($files as $file) {
			$this->currentFile++;

			pcntl_signal_dispatch();
			if ($this->isInterrupted) {
				break;
			}

			$this->comment('['.$this->currentFile.'/'.$totalFiles.'] Importing track ['. $file->getFilename() .']...');

			if (in_array($file->getExtension(), $this->ignoredExtensions)) {
				$this->comment('This is not an audio file! Skipping...'.PHP_EOL);
				continue;
			}


			// Has this track already been imported?
			$importedTrack = DB::table('mlpma_tracks')
			                   ->where('filename', '=', $file->getFilename())
			                   ->first();

			if ($importedTrack) {
				$this->comment('This track has already been imported! Skipping...' . PHP_EOL);
				continue;
			}


			//==========================================================================================================
			// Extract the original tags.
			//==========================================================================================================
			$getId3 = new getID3;

			// all tags read by getID3, including the cover art
			$allTags = $getId3->analyze($file->getPathname());

			// tags specific to a file format (ID3 or Atom), pre-normalization but with cover art removed
			$rawTags = [];

			// normalized tags used by Pony.fm
			$parsedTags = [];

			if ($file->getExtension() === 'mp3') {
				list($parsedTags, $rawTags) = $this->getId3Tags($allTags);

			} else if ($file->getExtension() === 'm4a') {
				list($parsedTags, $rawTags) = $this->getAtomTags($allTags);
			}


			//==========================================================================================================
			// Determine the release date.
			//==========================================================================================================
			$modifiedDate = Carbon::createFromTimeStampUTC(File::lastModified($file->getPathname()));
			$taggedYear = $parsedTags['year'];

			$this->info('Modification year: '.$modifiedDate->year);
			$this->info('Tagged year: '.$taggedYear);

			if ($taggedYear !== null && $modifiedDate->year === $taggedYear) {
				$releasedAt = $modifiedDate;

			} else if ($taggedYear !== null && $modifiedDate->year !== $taggedYear) {
				$this->error('Release years don\'t match! Using the tagged year...');
				$releasedAt = Carbon::create($taggedYear);

			} else {
				// $taggedYear is null
				$this->error('This track isn\'t tagged with its release year! Using the track\'s last modified date...');
				$releasedAt = $modifiedDate;
			}

			// This is later used by the classification/publishing script to determine the publication date.
			$parsedTags['released_at'] = $releasedAt->toDateTimeString();

			//==========================================================================================================
			// Does this track have vocals?
			//==========================================================================================================
			$isVocal = $parsedTags['lyrics'] !== null;


			//==========================================================================================================
			// Fill in the title tag if it's missing.
			//==========================================================================================================
			if (!$parsedTags['title']) {
				$parsedTags['title'] = $file->getBasename('.'.$file->getExtension());
			}


			//==========================================================================================================
			// Determine the genre.
			//==========================================================================================================
			$genreName = $parsedTags['genre'];
			$this->info('Genre: '.$genreName);

			if ($genreName) {
				$genre = Genre::where('name', '=', $genreName)->first();
				if ($genre) {
					$genreId = $genre->id;

				} else {
					$genre = new Genre();
					$genre->name = $genreName;
					$genre->slug = Str::slug($genreName);
					$genre->save();
					$genreId = $genre->id;
					$this->comment('Created a new genre!');
				}

			} else {
				$genreId = $UNKNOWN_GENRE->id; // "Unknown" genre ID
			}


			//==========================================================================================================
			// Determine which artist account this file belongs to using the containing directory.
			//==========================================================================================================
			$this->info('Path to file: '.$file->getRelativePath());
			$path_components = explode(DIRECTORY_SEPARATOR, $file->getRelativePath());
			$artist_name = $path_components[0];
			$album_name = array_key_exists(1, $path_components) ? $path_components[1] : null;

			$this->info('Artist: '.$artist_name);
			$this->info('Album: '.$album_name);

			$artist = User::where('display_name', '=', $artist_name)->first();

			if (!$artist) {
				$artist = new User;
				$artist->display_name = $artist_name;
				$artist->email = null;
				$artist->is_archived = true;

				$artist->slug = Str::slug($artist_name);

				$slugExists = User::where('slug', '=', $artist->slug)->first();
				if ($slugExists) {
					$this->error('Horsefeathers! The slug '.$artist->slug.' is already taken!');
					$artist->slug = $artist->slug.'-'.Str::random(4);
				}

				$artist->save();
			}

			//==========================================================================================================
			// Extract the cover art, if any exists.
			//==========================================================================================================
			$this->comment('Extracting cover art!');
			$coverId = null;
			if (array_key_exists('comments', $allTags) && array_key_exists('picture', $allTags['comments'])) {
				$image = $allTags['comments']['picture'][0];

				if ($image['image_mime'] === 'image/png') {
					$extension = 'png';

				} else if ($image['image_mime'] === 'image/jpeg') {
					$extension = 'jpg';

				} else if ($image['image_mime'] === 'image/gif') {
					$extension = 'gif';

				} else {
					$this->error('Unknown cover art format!');
				}

				// write temporary image file
				$imageFilename = $file->getFilename() . ".cover.$extension";
				$imageFilePath = "$tmpPath/".$imageFilename;
				File::put($imageFilePath, $image['data']);


				$imageFile = new UploadedFile($imageFilePath, $imageFilename, $image['image_mime']);

				$cover = Image::upload($imageFile, $artist);
				$coverId = $cover->id;

			} else {
				$this->comment('No cover art found!');
			}


			//==========================================================================================================
			// Is this part of an album?
			//==========================================================================================================
			$albumId = null;
			$albumName = $parsedTags['album'];

			if ($albumName !== null) {
				$album = Album::where('user_id', '=', $artist->id)
					->where('title', '=', $albumName)
					->first();

				if (!$album) {
					$album = new Album;

					$album->title = $albumName;
					$album->user_id = $artist->id;
					$album->cover_id = $coverId;

					$album->save();
				}

				$albumId = $album->id;
			}


			//==========================================================================================================
			// Save this track.
			//==========================================================================================================
			// "Upload" the track to Pony.fm
			$this->comment('Transcoding the track!');
			Auth::loginUsingId($artist->id);

			$trackFile = new UploadedFile($file->getPathname(), $file->getFilename(), $allTags['mime_type']);
			Input::instance()->files->add(['track' => $trackFile]);

			$upload = new UploadTrackCommand(true, true);
			$result = $upload->execute();

			if ($result->didFail()) {
				$this->error(json_encode($result->getValidator()->messages()->getMessages(), JSON_PRETTY_PRINT));

			} else {
				// Save metadata.
				$track = Track::find($result->getResponse()['id']);

				$track->title = $parsedTags['title'];
				$track->cover_id = $coverId;
				$track->album_id = $albumId;
				$track->genre_id = $genreId;
				$track->track_number = $parsedTags['track_number'];
				$track->released_at = $releasedAt;
				$track->description = $parsedTags['comments'];
				$track->is_downloadable = true;
				$track->lyrics = $parsedTags['lyrics'];
				$track->is_vocal = $isVocal;
				$track->license_id = 2;
				$track->save();

				// If we made it to here, the track is intact! Log the import.
				DB::table('mlpma_tracks')
					->insert([
						'track_id' => $result->getResponse()['id'],
					    'path' => $file->getRelativePath(),
					    'filename' => $file->getFilename(),
					    'extension' => $file->getExtension(),
					    'imported_at' => Carbon::now(),
					    'parsed_tags' => json_encode($parsedTags),
					    'raw_tags' => json_encode($rawTags),
					]);
			}

			echo PHP_EOL.PHP_EOL;
		}
	}

	/**
	 * Get the console command arguments.
	 *
	 * @return array
	 */
	protected function getArguments()
	{
		return array();
	}

	/**
	 * Get the console command options.
	 *
	 * @return array
	 */
	protected function getOptions()
	{
		return array(
			array('startAt', null, InputOption::VALUE_OPTIONAL, 'Track to start importing from. Useful for resuming an interrupted import.', 1),
		);
	}


	/**
	 * @param array $rawTags
	 * @return array
	 */
	protected function getId3Tags($rawTags) {
		if (array_key_exists('id3v2', $rawTags['tags'])) {
			$tags = $rawTags['tags']['id3v2'];

		} else if (array_key_exists('id3v1', $rawTags['tags'])) {
			$tags = $rawTags['tags']['id3v1'];

		} else {
			$tags = [];
		}

		$comment = null;

		if (isset($tags['comment'])) {
			// The "comment" tag comes in with a badly encoded string index
			// so its array key has to be used implicitly.
			$key = array_keys($tags['comment'])[0];

			// The comment may have a null byte at the end. trim() removes it.
			$comment = trim($tags['comment'][$key]);

			// Replace the malformed comment with the "fixed" one.
			unset($tags['comment'][$key]);
			$tags['comment'][0] = $comment;
		}

		return [
			[
				'title' => isset($tags['title']) ? $tags['title'][0] : null,
				'artist' => isset($tags['artist']) ? $tags['artist'][0] : null,
				'band'  => isset($tags['band']) ? $tags['band'][0] : null,
				'genre' => isset($tags['genre']) ? $tags['genre'][0] : null,
				'track_number' => isset($tags['track_number']) ? $tags['track_number'][0] : null,
				'album' => isset($tags['album']) ? $tags['album'][0] : null,
				'year'  => isset($tags['year']) ? (int) $tags['year'][0] : null,
				'comments' => $comment,
				'lyrics' => isset($tags['unsynchronised_lyric']) ? $tags['unsynchronised_lyric'][0] : null,
			],
			$tags];
	}

	/**
	 * @param array $rawTags
	 * @return array
	 */
	protected function getAtomTags($rawTags) {
		$tags = $rawTags['tags']['quicktime'];

		$trackNumber = null;
		if (isset($tags['track_number'])) {
			$trackNumberComponents = explode('/', $tags['track_number'][0]);
			$trackNumber = $trackNumberComponents[0];
		}

		return [
			[
				'title' => isset($tags['title']) ? $tags['title'][0] : null,
				'artist' => isset($tags['artist']) ? $tags['artist'][0] : null,
				'band' => isset($tags['band']) ? $tags['band'][0] : null,
				'album_artist' => isset($tags['album_artist']) ? $tags['album_artist'][0] : null,
				'genre' => isset($tags['genre']) ? $tags['genre'][0] : null,
				'track_number' => $trackNumber,
				'album' => isset($tags['album']) ? $tags['album'][0] : null,
				'year' => isset($tags['year']) ? (int) $tags['year'][0] : null,
				'comments' => isset($tags['comments']) ? $tags['comments'][0] : null,
				'lyrics' => isset($tags['lyrics']) ? $tags['lyrics'][0] : null,
			],
			$tags];
	}

}