<?php
 
 namespace Illuminate\Support;
 
 use Illuminate\Console\Application as Artisan;
 use Illuminate\Contracts\Support\DeferrableProvider;
 
 abstract class ServiceProvider
 {
     /**
      * The application instance.
      *
      * @var \Illuminate\Contracts\Foundation\Application
      */
     protected $app;
 
     /**
      * Indicates if loading of the provider is deferred.
      *
      * @deprecated Implement the \Illuminate\Contracts\Support\DeferrableProvider interface instead. Will be removed in Laravel 6.0.
      *
      * @var bool
      */
     protected $defer = false;
 
     /**
      * The paths that should be published.
      *
      * @var array
      */
     public static $publishes = [];
 
     /**
      * The paths that should be published by group.
      *
      * @var array
      */
     public static $publishGroups = [];
 
     /**
      * Create a new service provider instance.
      *
      * @param  \Illuminate\Contracts\Foundation\Application  $app
      * @return void
      */
     public function __construct($app)
     {
         $this->app = $app;
     }
 
     /**
      * Register any application services.
      *
      * @return void
      */
     public function register()
     {
         //
     }
 
     /**
      * Merge the given configuration with the existing configuration.
      *
      * @param  string  $path
      * @param  string  $key
      * @return void
      */
     protected function mergeConfigFrom($path, $key)
     {
         $config = $this->app['config']->get($key, []);
 
         $this->app['config']->set($key, array_merge(require $path, $config));
     }
 
     /**
      * Load the given routes file if routes are not already cached.
      *
      * @param  string  $path
      * @return void
      */
     protected function loadRoutesFrom($path)
     {
         if (! $this->app->routesAreCached()) {
             require $path;
         }
     }
 
     /**
      * Register a view file namespace.
      *
      * @param  string|array  $path
      * @param  string  $namespace
      * @return void
      */
     protected function loadViewsFrom($path, $namespace)
     {
         if (is_array($this->app->config['view']['paths'])) {
             foreach ($this->app->config['view']['paths'] as $viewPath) {
                 if (is_dir($appPath = $viewPath.'/vendor/'.$namespace)) {
                     $this->app['view']->addNamespace($namespace, $appPath);
                 }
             }
         }
 
         $this->app['view']->addNamespace($namespace, $path);
     }
 
     /**
      * Register a translation file namespace.
      *
      * @param  string  $path
      * @param  string  $namespace
      * @return void
      */
     protected function loadTranslationsFrom($path, $namespace)
     {
         $this->app['translator']->addNamespace($namespace, $path);
     }
 
     /**
      * Register a JSON translation file path.
      *
      * @param  string  $path
      * @return void
      */
     protected function loadJsonTranslationsFrom($path)
     {
         $this->app['translator']->addJsonPath($path);
     }
 
     /**
      * Register a database migration path.
      *
      * @param  array|string  $paths
      * @return void
      */
     protected function loadMigrationsFrom($paths)
     {
         $this->app->afterResolving('migrator', function ($migrator) use ($paths) {
             foreach ((array) $paths as $path) {
                 $migrator->path($path);
             }
         });
     }
 
     /**
      * Register paths to be published by the publish command.
      *
      * @param  array  $paths
      * @param  mixed  $groups
      * @return void
      */
     protected function publishes(array $paths, $groups = null)
     {
         $this->ensurePublishArrayInitialized($class = static::class);
 
         static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);
 
         foreach ((array) $groups as $group) {
             $this->addPublishGroup($group, $paths);
         }
     }
 
     /**
      * Ensure the publish array for the service provider is initialized.
      *
      * @param  string  $class
      * @return void
      */
     protected function ensurePublishArrayInitialized($class)
     {
         if (! array_key_exists($class, static::$publishes)) {
             static::$publishes[$class] = [];
         }
     }
 
     /**
      * Add a publish group / tag to the service provider.
      *
      * @param  string  $group
      * @param  array  $paths
      * @return void
      */
     protected function addPublishGroup($group, $paths)
     {
         if (! array_key_exists($group, static::$publishGroups)) {
             static::$publishGroups[$group] = [];
         }
 
         static::$publishGroups[$group] = array_merge(
             static::$publishGroups[$group], $paths
         );
     }
 
     /**
      * Get the paths to publish.
      *
      * @param  string  $provider
      * @param  string  $group
      * @return array
      */
     public static function pathsToPublish($provider = null, $group = null)
     {
         if (! is_null($paths = static::pathsForProviderOrGroup($provider, $group))) {
             return $paths;
         }
 
         return collect(static::$publishes)->reduce(function ($paths, $p) {
             return array_merge($paths, $p);
         }, []);
     }
 
     /**
      * Get the paths for the provider or group (or both).
      *
      * @param  string|null  $provider
      * @param  string|null  $group
      * @return array
      */
     protected static function pathsForProviderOrGroup($provider, $group)
     {
         if ($provider && $group) {
             return static::pathsForProviderAndGroup($provider, $group);
         } elseif ($group && array_key_exists($group, static::$publishGroups)) {
             return static::$publishGroups[$group];
         } elseif ($provider && array_key_exists($provider, static::$publishes)) {
             return static::$publishes[$provider];
         } elseif ($group || $provider) {
             return [];
         }
     }
 
     /**
      * Get the paths for the provider and group.
      *
      * @param  string  $provider
      * @param  string  $group
      * @return array
      */
     protected static function pathsForProviderAndGroup($provider, $group)
     {
         if (! empty(static::$publishes[$provider]) && ! empty(static::$publishGroups[$group])) {
             return array_intersect_key(static::$publishes[$provider], static::$publishGroups[$group]);
         }
 
         return [];
     }
 
     /**
      * Get the service providers available for publishing.
      *
      * @return array
      */
     public static function publishableProviders()
     {
         return array_keys(static::$publishes);
     }
 
     /**
      * Get the groups available for publishing.
      *
      * @return array
      */
     public static function publishableGroups()
     {
         return array_keys(static::$publishGroups);
     }
 
     /**
      * Register the package's custom Artisan commands.
      *
      * @param  array|mixed  $commands
      * @return void
      */
     public function commands($commands)
     {
         $commands = is_array($commands) ? $commands : func_get_args();
 
         Artisan::starting(function ($artisan) use ($commands) {
             $artisan->resolveCommands($commands);
         });
     }
 
     /**
      * Get the services provided by the provider.
      *
      * @return array
      */
     public function provides()
     {
         return [];
     }
 
     /**
      * Get the events that trigger this service provider to register.
      *
      * @return array
      */
     public function when()
     {
         return [];
     }
 
     /**
      * Determine if the provider is deferred.
      *
      * @return bool
      */
     public function isDeferred()
     {
         return $this->defer || $this instanceof DeferrableProvider;
     }
 }