<?php

    class Asset extends Depreciable
    {

        use SoftDeletingTrait;
        protected $dates = [ 'deleted_at' ];

        protected $table = 'assets';
        protected $errors;
        protected $rules = [
            'name'            => 'alpha_space|min:2|max:255',
            'model_id'        => 'required',
            'status_id'       => 'required',
            'warranty_months' => 'integer|min:0|max:240',
            'note'            => 'alpha_space',
            'notes'           => 'alpha_space',
            'pysical'         => 'integer',
            'checkout_date'   => 'date|max:10|min:10',
            'checkin_date'    => 'date|max:10|min:10',
            'supplier_id'     => 'integer',
            'asset_tag'       => 'required|alpha_space|min:3|max:255|unique:assets,asset_tag,{id}',
            'status'          => 'integer'
        ];


        /**
         * Checkout asset
         */
        public function checkOutToUser($user, $admin, $checkout_at = null, $expected_checkin = null, $note = null, $name = null) {
            $this->assigneduser()->associate($user);
            $this->name = $name;

            $settings = Setting::getSettings();

            if($this->requireAcceptance()) {
              $this->accepted="pending";
            }

            if($this->save()) {

                $log_id = $this->createCheckoutLog($checkout_at, $admin, $user, $expected_checkin, $note);

                if ((($this->requireAcceptance()=='1')  || ($this->getEula())) && ($user->email!='')) {
                    $this->checkOutNotifyMail($log_id, $user, $checkout_at, $expected_checkin, $note);
                }

                if ($settings->slack_endpoint) {
                    $this->checkOutNotifySlack($settings, $admin, $note);
                }
                return true;

            }
            return false;

        }

        public function checkOutNotifyMail($log_id, $user, $checkout_at, $expected_checkin, $note) {

            $data['log_id'] = $log_id;
            $data['eula'] = $this->getEula();
            $data['first_name'] = $user->first_name;
            $data['item_name'] = $this->showAssetName();
            $data['checkout_date'] = $checkout_at;
            $data['expected_checkin'] = $expected_checkin;
            $data['item_tag'] = $this->asset_tag;
            $data['note'] = $note;
            $data['require_acceptance'] = $this->requireAcceptance();

            if ((($this->requireAcceptance()=='1')  || ($this->getEula())) && (!Config::get('app.lock_passwords'))) {

	            Mail::send('emails.accept-asset', $data, function ($m) use ($user) {
	                $m->to($user->email, $user->first_name . ' ' . $user->last_name);
	                $m->subject('Confirm asset delivery');
	            });
            }

        }

        public function checkOutNotifySlack($settings, $admin, $note = null) {

			if ($settings->slack_endpoint) {

                $slack_settings = [
                    'username' => $settings->botname,
                    'channel' => $settings->slack_channel,
                    'link_names' => true
                ];

                $client = new \Maknz\Slack\Client($settings->slack_endpoint,$slack_settings);

                    try {
                        $client->attach([
                            'color' => 'good',
                            'fields' => [
                                [
                                    'title' => 'Checked Out:',
                                    'value' => 'HARDWARE asset <'.Config::get('app.url').'/hardware/'.$this->id.'/view'.'|'.$this->showAssetName().'> checked out to <'.Config::get('app.url').'/admin/users/'.$this->assigned_to.'/view|'.$this->assigneduser->fullName().'> by <'.Config::get('app.url').'/hardware/'.$this->id.'/view'.'|'.$admin->fullName().'>.'
                                ],
                                [
                                    'title' => 'Note:',
                                    'value' => e($note)
                                ],


                            ]
                        ])->send('Asset Checked Out');

                    } catch (Exception $e) {
                        print_r($e);
                    }
                }

        }

        public function createCheckoutLog($checkout_at = null, $admin, $user, $expected_checkin = null, $note = null) {

            $logaction = new Actionlog();
            $logaction->asset_id = $this->id;
            $logaction->checkedout_to = $this->assigned_to;
            $logaction->asset_type = 'hardware';
            $logaction->location_id = $user->location_id;
            $logaction->adminlog()->associate($admin);
            $logaction->note = $note;
            if ($checkout_at) {
                $logaction->created_at = $checkout_at;
            }
            $log = $logaction->logaction('checkout');
            return $logaction->id;
        }


        /**
         * Set depreciation relationship
         */
        public function depreciation()
        {
            return $this->model->belongsTo( 'Depreciation', 'depreciation_id' );
        }

        /**
         * Get depreciation attribute from associated asset model
         */
        public function get_depreciation()
        {
            return $this->model->depreciation;
        }

        /**
         * Get uploads for this asset
         */
        public function uploads()
        {

            return $this->hasMany( 'Actionlog', 'asset_id' )
                        ->where( 'asset_type', '=', 'hardware' )
                        ->where( 'action_type', '=', 'uploaded' )
                        ->whereNotNull( 'filename' )
                        ->orderBy( 'created_at', 'desc' );
        }

        public function assigneduser()
        {

            return $this->belongsTo( 'User', 'assigned_to' )
                        ->withTrashed();
        }

        /**
         * Get the asset's location based on the assigned user
         **/
        public function assetloc()
        {

            if ($this->assigneduser) {
                return $this->assigneduser->userloc();
            } else {
                return $this->belongsTo( 'Location', 'rtd_location_id' );
            }

        }

        /**
         * Get the asset's location based on default RTD location
         **/
        public function defaultLoc()
        {

            return $this->belongsTo( 'Location', 'rtd_location_id' );
        }

        /**
         * Get action logs for this asset
         */
        public function assetlog()
        {

            return $this->hasMany( 'Actionlog', 'asset_id' )
                        ->where( 'asset_type', '=', 'hardware' )
                        ->orderBy( 'created_at', 'desc' )
                        ->withTrashed();
        }

        /**
         * assetmaintenances
         * Get improvements for this asset
         *
         * @return mixed
         * @author  Vincent Sposato <vincent.sposato@gmail.com>
         * @version v1.0
         */
        public function assetmaintenances()
        {

            return $this->hasMany( 'AssetMaintenance', 'asset_id' )
                        ->orderBy( 'created_at', 'desc' )
                        ->withTrashed();
        }

        /**
         * Get action logs for this asset
         */
        public function adminuser()
        {

            return $this->belongsTo( 'User', 'user_id' );
        }

        /**
         * Get total assets
         */
        public static function assetcount()
        {

            return DB::table( 'assets' )
                     ->where( 'physical', '=', '1' )
                     ->whereNull( 'deleted_at', 'and' )
                     ->count();
        }

        /**
         * Get total assets not checked out
         */
        public static function availassetcount()
        {

            return Asset::RTD()
                        ->whereNull( 'deleted_at' )
                        ->count();

        }

        /**
         * Get requestable assets
         */
        public static function getRequestable()
        {

            return Asset::Requestable()
                        ->whereNull( 'deleted_at' )
                        ->count();

        }

        /**
         * Get total assets
         */
        public function assetstatus()
        {

            return $this->belongsTo( 'Statuslabel', 'status_id' );
        }

        /**
         * Get name for EULA
         **/
        public function showAssetName()
        {

            if ($this->name == '') {
                return $this->model->name;
            } else {
                return $this->name;
            }
        }

        public function warrantee_expires()
        {

            $date = date_create( $this->purchase_date );
            date_add( $date, date_interval_create_from_date_string( $this->warranty_months . ' months' ) );

            return date_format( $date, 'Y-m-d' );
        }

        public function model()
        {

            return $this->belongsTo( 'Model', 'model_id' )
                        ->withTrashed();
        }

        public static function getExpiringWarrantee( $days = 30 )
        {

            return Asset::where( 'archived', '=', '0' )
                        ->whereNotNull( 'warranty_months' )
                        ->whereNotNull( 'purchase_date' )
                        ->whereNull( 'deleted_at' )
                        ->whereRaw( DB::raw( 'DATE_ADD(`purchase_date`,INTERVAL `warranty_months` MONTH) <= DATE(NOW() + INTERVAL '
                                             . $days
                                             . ' DAY) AND DATE_ADD(`purchase_date`,INTERVAL `warranty_months` MONTH) > NOW()' ) )
                        ->orderBy( 'purchase_date', 'ASC' )
                        ->get();

        }

        /**
         * Get the license seat information
         **/
        public function licenses()
        {

            return $this->belongsToMany( 'License', 'license_seats', 'asset_id', 'license_id' );

        }

        public function licenseseats()
        {

            return $this->hasMany( 'LicenseSeat', 'asset_id' );
        }

        public function supplier()
        {

            return $this->belongsTo( 'Supplier', 'supplier_id' );
        }

        public function months_until_eol()
        {

            $today = date( "Y-m-d" );
            $d1    = new DateTime( $today );
            $d2    = new DateTime( $this->eol_date() );

            if ($this->eol_date() > $today) {
                $interval = $d2->diff( $d1 );
            } else {
                $interval = null;
            }

            return $interval;
        }

        public function eol_date()
        {

            if (( $this->purchase_date ) && ( $this->model )) {
                $date = date_create( $this->purchase_date );

                // Use the asset-level EOL if one is given
                if (($this->warranty_months) && ($this->warranty_months!='0')) {
                    date_add( $date, date_interval_create_from_date_string( $this->warranty_months . ' months' ));
                // If a warranty month period wasn't specified on the asset level, use the model
                } else {
                    date_add( $date, date_interval_create_from_date_string( $this->model->eol . ' months' ));
                }

                return date_format( $date, 'Y-m-d' );
            }

        }

        /**
         * Get total assets
         */
        public static function autoincrement_asset()
        {

            $settings = Setting::getSettings();

            if ($settings->auto_increment_assets == '1') {
                $asset_tag = DB::table( 'assets' )
                               ->where( 'physical', '=', '1' )
                               ->max( 'id' );

                return $settings->auto_increment_prefix . ( $asset_tag + 1 );
            } else {
                return false;
            }
        }

        public function checkin_email()
        {

            return $this->model->category->checkin_email;
        }

        public function requireAcceptance()
        {

            return $this->model->category->require_acceptance;
        }

        public function getEula()
        {

            $Parsedown = new Parsedown();

            if ($this->model->category->eula_text) {
                return $Parsedown->text( e( $this->model->category->eula_text ) );
            } elseif ($this->model->category->use_default_eula == '1') {
                return $Parsedown->text( e( Setting::getSettings()->default_eula_text ) );
            } else {
                return null;
            }

        }


        /**
         * -----------------------------------------------
         * BEGIN QUERY SCOPES
         * -----------------------------------------------
         **/

        /**
         * Query builder scope for hardware
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeHardware( $query )
        {

            return $query->where( 'physical', '=', '1' );
        }

        /**
         * Query builder scope for pending assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopePending( $query )
        {

            return $query->whereHas( 'assetstatus', function ( $query ) {

                $query->where( 'deployable', '=', 0 )
                      ->where( 'pending', '=', 1 )
                      ->where( 'archived', '=', 0 );
            } );
        }

        /**
         * Query builder scope for RTD assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeRTD( $query )
        {

            return $query->whereNULL( 'assigned_to' )
                         ->whereHas( 'assetstatus', function ( $query ) {

                             $query->where( 'deployable', '=', 1 )
                                   ->where( 'pending', '=', 0 )
                                   ->where( 'archived', '=', 0 );
                         } );
        }

        /**
         * Query builder scope for Undeployable assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeUndeployable( $query )
        {

            return $query->whereHas( 'assetstatus', function ( $query ) {

                $query->where( 'deployable', '=', 0 )
                      ->where( 'pending', '=', 0 )
                      ->where( 'archived', '=', 0 );
            } );
        }

        /**
         * Query builder scope for Archived assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeArchived( $query )
        {

            return $query->whereHas( 'assetstatus', function ( $query ) {

                $query->where( 'deployable', '=', 0 )
                      ->where( 'pending', '=', 0 )
                      ->where( 'archived', '=', 1 );
            } );
        }

        /**
         * Query builder scope for Deployed assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeDeployed( $query )
        {

            return $query->where( 'assigned_to', '>', '0' );
        }

        /**
         * Query builder scope for Requestable assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeRequestableAssets( $query )
        {

            return $query->where( 'requestable', '=', 1 )
                         ->whereHas( 'assetstatus', function ( $query ) {

                             $query->where( 'deployable', '=', 1 )
                                   ->where( 'pending', '=', 0 )
                                   ->where( 'archived', '=', 0 );
                         } );
        }

        /**
         * Query builder scope for Deleted assets
         *
         * @param  Illuminate\Database\Query\Builder $query Query builder instance
         *
         * @return Illuminate\Database\Query\Builder          Modified query builder
         */

        public function scopeDeleted( $query )
        {

            return $query->whereNotNull( 'deleted_at' );
        }

        /**
         * scopeInModelList
         * Get all assets in the provided listing of model ids
         *
         * @param       $query
         * @param array $modelIdListing
         *
         * @return mixed
         * @author  Vincent Sposato <vincent.sposato@gmail.com>
         * @version v1.0
         */
        public function scopeInModelList( $query, array $modelIdListing )
        {

            return $query->whereIn( 'model_id', $modelIdListing );
        }

        public function scopeNotYetAccepted( $query )
        {

            return $query->where( "accepted", "=", "pending" );
        }

        public function scopeRejected( $query )
        {

            return $query->where( "accepted", "=", "rejected" );
        }

        public function scopeAccepted( $query )
        {

            return $query->where( "accepted", "=", "accepted" );
        }

    }