<?php
  
  namespace Illuminate\Support\Testing\Fakes;
  
  use Closure;
  use Illuminate\Contracts\Mail\Factory;
  use Illuminate\Contracts\Mail\Mailable;
  use Illuminate\Contracts\Mail\Mailer;
  use Illuminate\Contracts\Mail\MailQueue;
  use Illuminate\Contracts\Queue\ShouldQueue;
  use Illuminate\Support\Traits\ReflectsClosures;
  use PHPUnit\Framework\Assert as PHPUnit;
  
  class MailFake implements Factory, Mailer, MailQueue
  {
      use ReflectsClosures;
  
      /**
       * The mailer currently being used to send a message.
       *
       * @var string
       */
      protected $currentMailer;
  
      /**
       * All of the mailables that have been sent.
       *
       * @var array
       */
      protected $mailables = [];
  
      /**
       * All of the mailables that have been queued.
       *
       * @var array
       */
      protected $queuedMailables = [];
  
      /**
       * Assert if a mailable was sent based on a truth-test callback.
       *
       * @param  string|\Closure  $mailable
       * @param  callable|int|null  $callback
       * @return void
       */
      public function assertSent($mailable, $callback = null)
      {
          if ($mailable instanceof Closure) {
              [$mailable, $callback] = [$this->firstClosureParameterType($mailable), $mailable];
          }
  
          if (is_numeric($callback)) {
              return $this->assertSentTimes($mailable, $callback);
          }
  
          $message = "The expected [{$mailable}] mailable was not sent.";
  
          if (count($this->queuedMailables) > 0) {
              $message .= ' Did you mean to use assertQueued() instead?';
          }
  
          PHPUnit::assertTrue(
              $this->sent($mailable, $callback)->count() > 0,
              $message
          );
      }
  
      /**
       * Assert if a mailable was sent a number of times.
       *
       * @param  string  $mailable
       * @param  int  $times
       * @return void
       */
      protected function assertSentTimes($mailable, $times = 1)
      {
          $count = $this->sent($mailable)->count();
  
          PHPUnit::assertSame(
              $times, $count,
              "The expected [{$mailable}] mailable was sent {$count} times instead of {$times} times."
          );
      }
  
      /**
       * Determine if a mailable was not sent based on a truth-test callback.
       *
       * @param  string  $mailable
       * @param  callable|null  $callback
       * @return void
       */
      public function assertNotSent($mailable, $callback = null)
      {
          PHPUnit::assertCount(
              0, $this->sent($mailable, $callback),
              "The unexpected [{$mailable}] mailable was sent."
          );
      }
  
      /**
       * Assert that no mailables were sent.
       *
       * @return void
       */
      public function assertNothingSent()
      {
          $mailableNames = collect($this->mailables)->map(function ($mailable) {
              return get_class($mailable);
          })->join(', ');
  
          PHPUnit::assertEmpty($this->mailables, 'The following mailables were sent unexpectedly: '.$mailableNames);
      }
  
      /**
       * Assert if a mailable was queued based on a truth-test callback.
       *
       * @param  string|\Closure  $mailable
       * @param  callable|int|null  $callback
       * @return void
       */
      public function assertQueued($mailable, $callback = null)
      {
          if ($mailable instanceof Closure) {
              [$mailable, $callback] = [$this->firstClosureParameterType($mailable), $mailable];
          }
  
          if (is_numeric($callback)) {
              return $this->assertQueuedTimes($mailable, $callback);
          }
  
          PHPUnit::assertTrue(
              $this->queued($mailable, $callback)->count() > 0,
              "The expected [{$mailable}] mailable was not queued."
          );
      }
  
      /**
       * Assert if a mailable was queued a number of times.
       *
       * @param  string  $mailable
       * @param  int  $times
       * @return void
       */
      protected function assertQueuedTimes($mailable, $times = 1)
      {
          $count = $this->queued($mailable)->count();
  
          PHPUnit::assertSame(
              $times, $count,
              "The expected [{$mailable}] mailable was queued {$count} times instead of {$times} times."
          );
      }
  
      /**
       * Determine if a mailable was not queued based on a truth-test callback.
       *
       * @param  string  $mailable
       * @param  callable|null  $callback
       * @return void
       */
      public function assertNotQueued($mailable, $callback = null)
      {
          PHPUnit::assertCount(
              0, $this->queued($mailable, $callback),
              "The unexpected [{$mailable}] mailable was queued."
          );
      }
  
      /**
       * Assert that no mailables were queued.
       *
       * @return void
       */
      public function assertNothingQueued()
      {
          $mailableNames = collect($this->queuedMailables)->map(function ($mailable) {
              return get_class($mailable);
          })->join(', ');
  
          PHPUnit::assertEmpty($this->queuedMailables, 'The following mailables were queued unexpectedly: '.$mailableNames);
      }
  
      /**
       * Get all of the mailables matching a truth-test callback.
       *
       * @param  string  $mailable
       * @param  callable|null  $callback
       * @return \Illuminate\Support\Collection
       */
      public function sent($mailable, $callback = null)
      {
          if (! $this->hasSent($mailable)) {
              return collect();
          }
  
          $callback = $callback ?: function () {
              return true;
          };
  
          return $this->mailablesOf($mailable)->filter(function ($mailable) use ($callback) {
              return $callback($mailable);
          });
      }
  
      /**
       * Determine if the given mailable has been sent.
       *
       * @param  string  $mailable
       * @return bool
       */
      public function hasSent($mailable)
      {
          return $this->mailablesOf($mailable)->count() > 0;
      }
  
      /**
       * Get all of the queued mailables matching a truth-test callback.
       *
       * @param  string  $mailable
       * @param  callable|null  $callback
       * @return \Illuminate\Support\Collection
       */
      public function queued($mailable, $callback = null)
      {
          if (! $this->hasQueued($mailable)) {
              return collect();
          }
  
          $callback = $callback ?: function () {
              return true;
          };
  
          return $this->queuedMailablesOf($mailable)->filter(function ($mailable) use ($callback) {
              return $callback($mailable);
          });
      }
  
      /**
       * Determine if the given mailable has been queued.
       *
       * @param  string  $mailable
       * @return bool
       */
      public function hasQueued($mailable)
      {
          return $this->queuedMailablesOf($mailable)->count() > 0;
      }
  
      /**
       * Get all of the mailed mailables for a given type.
       *
       * @param  string  $type
       * @return \Illuminate\Support\Collection
       */
      protected function mailablesOf($type)
      {
          return collect($this->mailables)->filter(function ($mailable) use ($type) {
              return $mailable instanceof $type;
          });
      }
  
      /**
       * Get all of the mailed mailables for a given type.
       *
       * @param  string  $type
       * @return \Illuminate\Support\Collection
       */
      protected function queuedMailablesOf($type)
      {
          return collect($this->queuedMailables)->filter(function ($mailable) use ($type) {
              return $mailable instanceof $type;
          });
      }
  
      /**
       * Get a mailer instance by name.
       *
       * @param  string|null  $name
       * @return \Illuminate\Mail\Mailer
       */
      public function mailer($name = null)
      {
          $this->currentMailer = $name;
  
          return $this;
      }
  
      /**
       * Begin the process of mailing a mailable class instance.
       *
       * @param  mixed  $users
       * @return \Illuminate\Mail\PendingMail
       */
      public function to($users)
      {
          return (new PendingMailFake($this))->to($users);
      }
  
      /**
       * Begin the process of mailing a mailable class instance.
       *
       * @param  mixed  $users
       * @return \Illuminate\Mail\PendingMail
       */
      public function bcc($users)
      {
          return (new PendingMailFake($this))->bcc($users);
      }
  
      /**
       * Send a new message with only a raw text part.
       *
       * @param  string  $text
       * @param  \Closure|string  $callback
       * @return void
       */
      public function raw($text, $callback)
      {
          //
      }
  
      /**
       * Send a new message using a view.
       *
       * @param  string|array  $view
       * @param  array  $data
       * @param  \Closure|string|null  $callback
       * @return void
       */
      public function send($view, array $data = [], $callback = null)
      {
          if (! $view instanceof Mailable) {
              return;
          }
  
          $view->mailer($this->currentMailer);
  
          $this->currentMailer = null;
  
          if ($view instanceof ShouldQueue) {
              return $this->queue($view, $data);
          }
  
          $this->mailables[] = $view;
      }
  
      /**
       * Queue a new e-mail message for sending.
       *
       * @param  \Illuminate\Contracts\Mail\Mailable|string|array  $view
       * @param  string|null  $queue
       * @return mixed
       */
      public function queue($view, $queue = null)
      {
          if (! $view instanceof Mailable) {
              return;
          }
  
          $view->mailer($this->currentMailer);
  
          $this->currentMailer = null;
  
          $this->queuedMailables[] = $view;
      }
  
      /**
       * Queue a new e-mail message for sending after (n) seconds.
       *
       * @param  \DateTimeInterface|\DateInterval|int  $delay
       * @param  \Illuminate\Contracts\Mail\Mailable|string|array  $view
       * @param  string|null  $queue
       * @return mixed
       */
      public function later($delay, $view, $queue = null)
      {
          $this->queue($view, $queue);
      }
  
      /**
       * Get the array of failed recipients.
       *
       * @return array
       */
      public function failures()
      {
          return [];
      }
  }