<?php

if ( !defined( 'WPINC' ) ) {
    die;
}

/**
 * Responsible control class
 *
 * @since      1.0.0
 * @package    Activities
 * @subpackage Activities/includes
 * @author     Mikal Naustdal <miknau94@gmail.com>
 */
class Activities_Responsible {
    /**
     * Adds action related to responsible users
     */
    static function init() {
        add_action( 'activities_archive_activity', array( __CLASS__, 'remove_user_responsibility' ) );
        add_action( 'activities_activate_activity', array( __CLASS__, 'restore_user_responsibility' ) );
    }

    /**
     * Sets responsibility restriction on a user
     *
     * @param int $user_id User to set restriction on
     * @param string $key Restriction key
     */
    static function set_user_responsibility( $user_id, $key ) {
        $current             = self::get_user_responsibility( $user_id, $key );
        $blog_id             = get_current_blog_id();
        $current[ $blog_id ] = 1;
        update_user_meta( $user_id, $key, $current );
    }

    /**
     * Deletes responsibility restriction on a user
     *
     * @param int $user_id User to delete restriction for
     * @param string $key Restriction key
     */
    static function delete_user_responsibility( $user_id, $key ) {
        $current = self::get_user_responsibility( $user_id, $key );
        $blog_id = get_current_blog_id();
        if ( isset( $current[ $blog_id ] ) ) {
            unset( $current[ $blog_id ] );
            update_user_meta( $user_id, $key, $current );
        }
    }

    /**
     * Retrieve responsibility restriction that's on a user
     *
     * @param int $user_id User to retrieve data for
     * @param string $key Restriction key
     *
     * @return  array   Array mapping for which site the user has restriction, site_id => 1
     */
    static function get_user_responsibility( $user_id, $key ) {
        $current = get_user_meta( $user_id, $key, true );
        if ( $current == '' ) {
            $current = array();
        }

        return $current;
    }

    /**
     * Checks if a user has responsibility restricted permissions
     *
     * @param int $user_id User to retrieve data for
     * @param string $key Restriction key
     * @param int $blog_id Blog to check on, defaults to current blog
     *
     * @return  bool    True if restricted, false otherwise
     */
    static function user_restricted( $user_id, $key, $blog_id = -1 ) {
        $current = self::get_user_responsibility( $user_id, $key );
        if ( $blog_id === -1 ) {
            $blog_id = get_current_blog_id();
        }
        if ( isset( $current[ $blog_id ] ) ) {
            return $current[ $blog_id ] == 1;
        } else {
            return false;
        }
    }

    /**
     * Checks if a user has restricted view permission
     *
     * @param int $user_id User to retrieve data for
     *
     * @return  bool    True if restricted, false otherwise
     */
    static function user_restricted_view( $user_id ) {
        return self::user_restricted( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
    }

    /**
     * Checks if a user has restricted edit permission
     *
     * @param int $user_id User to retrieve data for
     *
     * @return  bool    True if restricted, false otherwise
     */
    static function user_restricted_edit( $user_id ) {
        return self::user_restricted( $user_id, ACTIVITIES_RESPONSIBLE_EDIT );
    }

    /**
     * Checks if current user has restricted view permission
     *
     * @return  bool  True if restricted, false otherwise
     */
    static function current_user_restricted_view() {
        return self::user_restricted_view( get_current_user_id() );
    }

    /**
     * Checks if current user has restricted edit permission
     *
     * @return  bool  True if restricted, false otherwise
     */
    static function current_user_restricted_edit() {
        return self::user_restricted_edit( get_current_user_id() );
    }

    /**
     * Adds user access to responsible users depending on activities settings and wp roles
     * This should not add the ACTIVITIES_ADMINISTER_ACTIVITIES capability as it grants more permissions than it should to the responsible user,
     * and should only be granted by role permissions.
     *
     * @param int $user_id
     */
    static function update_user_responsiblity( $user_id ) {
        $user = new WP_User( $user_id );

        switch ( Activities_Options::get_option( ACTIVITIES_RESPONSIBLE_KEY ) ) {
            case ACTIVITIES_RESPONSIBLE_SAME:
                $user->remove_cap( ACTIVITIES_ACCESS_ACTIVITIES );
                self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
                self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_EDIT );
                break;

            case ACTIVITIES_RESPONSIBLE_VIEW:
                $role_access = self::get_user_role_override( $user );
                if ( !$role_access[ ACTIVITIES_ACCESS_ACTIVITIES ] ) {
                    $user->add_cap( ACTIVITIES_ACCESS_ACTIVITIES );
                    self::set_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
                } else {
                    $user->remove_cap( ACTIVITIES_ACCESS_ACTIVITIES );
                    self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
                }
                delete_user_meta( $user_id, ACTIVITIES_RESPONSIBLE_EDIT );
                break;

            case ACTIVITIES_RESPONSIBLE_EDIT:
                $role_access = self::get_user_role_override( $user );
                if ( !$role_access[ ACTIVITIES_ACCESS_ACTIVITIES ] ) {
                    $user->add_cap( ACTIVITIES_ACCESS_ACTIVITIES );
                    self::set_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
                } else {
                    $user->remove_cap( ACTIVITIES_ACCESS_ACTIVITIES );
                    self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
                }
                if ( !$role_access[ ACTIVITIES_ADMINISTER_ACTIVITIES ] ) {
                    self::set_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_EDIT );
                } else {
                    self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_EDIT );
                }
                break;
        }
    }


    /**
     * Removes all responsibility from a user if they no longer has any responsibility over activities
     *
     * @param int $activity_id Activity getting a new responsible user
     */
    static function remove_user_responsibility( $activity_id ) {
        global $wpdb;

        $table_name = Activities::get_table_name( 'activity' );

        $rep_id = $wpdb->get_var( $wpdb->prepare(
            "SELECT responsible_id
      FROM $table_name
      WHERE activity_id = %d
      ",
            $activity_id
        ) );

        if ( $rep_id === null ) {
            return;
        }

        $count = $wpdb->get_var( $wpdb->prepare(
            "SELECT COUNT(responsible_id)
      FROM $table_name
      WHERE responsible_id = %d
      AND archive = 0
      ",
            $rep_id
        ) );

        if ( $count <= 1 ) {
            $prev_user = new WP_User( $rep_id );
            $prev_user->remove_cap( ACTIVITIES_ACCESS_ACTIVITIES );
            self::delete_user_responsibility( $rep_id, ACTIVITIES_RESPONSIBLE_VIEW );
            self::delete_user_responsibility( $rep_id, ACTIVITIES_RESPONSIBLE_EDIT );
        }
    }

    /**
     * Restores all responsibility from a user if they have more than 1 activity they are responsible for
     *
     * @param int $activity_id Activity getting a new responsible user
     */
    static function restore_user_responsibility( $activity_id ) {
        global $wpdb;

        $table_name = Activities::get_table_name( 'activity' );

        $rep_id = $wpdb->get_var( $wpdb->prepare(
            "SELECT responsible_id
      FROM $table_name
      WHERE activity_id = %d
      ",
            $activity_id
        ) );

        $count = $wpdb->get_var( $wpdb->prepare(
            "SELECT COUNT(responsible_id)
      FROM $table_name
      WHERE responsible_id = %d
      AND archive = 0
      ",
            $rep_id
        ) );

        if ( $count >= 1 ) {
            self::update_user_responsiblity( $rep_id );
        }
    }

    /**
     * Updates all users responsibilities
     */
    static function update_all_users_responsiblity() {
        global $wpdb;

        $table_name = Activities::get_table_name( 'activity' );

        $users = $wpdb->get_results(
            "SELECT DISTINCT responsible_id
      FROM $table_name
      WHERE archive = 0
      "
        );

        foreach ( $users as $id ) {
            if ( $id->responsible_id === null ) {
                continue;
            }
            self::update_user_responsiblity( $id->responsible_id );
        }
    }

    /**
     * Removes all users responsibilities
     */
    static function remove_all_users_responsiblity() {
        global $wpdb;

        $table_name = Activities::get_table_name( 'activity' );

        $users = $wpdb->get_col(
            "SELECT DISTINCT responsible_id
      FROM $table_name
      WHERE archive = 0
      "
        );

        foreach ( $users as $user_id ) {
            $user = new WP_User( $user_id );
            $user->remove_cap( ACTIVITIES_ACCESS_ACTIVITIES );
            self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_VIEW );
            self::delete_user_responsibility( $user_id, ACTIVITIES_RESPONSIBLE_EDIT );
        }
    }

    /**
     * Checks if the user role overrides responsibility access
     *
     * @param WP_User $user
     *
     * @return   array   ACTIVITIES_ACCESS_ACTIVITIES and ACTIVITIES_ADMINISTER_ACTIVITIES to true if role has the capability, otherwise false
     */
    static function get_user_role_override( $user ) {
        global $wp_roles;

        $access = array(
            ACTIVITIES_ACCESS_ACTIVITIES     => false,
            ACTIVITIES_ADMINISTER_ACTIVITIES => false
        );
        foreach ( $user->roles as $role ) {
            $caps = $wp_roles->get_role( $role )->capabilities;
            if ( isset( $caps[ ACTIVITIES_ACCESS_ACTIVITIES ] ) && !$access[ ACTIVITIES_ACCESS_ACTIVITIES ] ) {
                $access[ ACTIVITIES_ACCESS_ACTIVITIES ] = $caps[ ACTIVITIES_ACCESS_ACTIVITIES ];
            }
            if ( isset( $caps[ ACTIVITIES_ADMINISTER_ACTIVITIES ] ) && !$access[ ACTIVITIES_ADMINISTER_ACTIVITIES ] ) {
                $access[ ACTIVITIES_ADMINISTER_ACTIVITIES ] = $caps[ ACTIVITIES_ADMINISTER_ACTIVITIES ];
            }
            if ( $access[ ACTIVITIES_ACCESS_ACTIVITIES ] && $access[ ACTIVITIES_ADMINISTER_ACTIVITIES ] ) {
                break;
            }
        }

        return $access;
    }
}

Activities_Responsible::init();