import json
import logging

from datetime import datetime

from django.utils.timezone import UTC
from lxml import etree
from pkg_resources import resource_string

from xblock.fields import Dict, String, Scope, Boolean, Float, Reference

from xmodule.capa_module import ComplexEncoder
from xmodule.fields import Date, Timedelta
from xmodule.modulestore.exceptions import ItemNotFoundError, NoPathToItem
from xmodule.raw_module import RawDescriptor
from xmodule.timeinfo import TimeInfo
from xmodule.x_module import XModule, module_attr
from xmodule.open_ended_grading_classes.peer_grading_service import PeerGradingService, MockPeerGradingService
from xmodule.open_ended_grading_classes.grading_service_module import GradingServiceError
from xmodule.validation import StudioValidation, StudioValidationMessage

from open_ended_grading_classes import combined_open_ended_rubric

log = logging.getLogger(__name__)

# Make '_' a no-op so we can scrape strings
_ = lambda text: text


EXTERNAL_GRADER_NO_CONTACT_ERROR = "Failed to contact external graders.  Please notify course staff."
MAX_ALLOWED_FEEDBACK_LENGTH = 5000


class PeerGradingFields(object):
    use_for_single_location = Boolean(
        display_name=_("Show Single Problem"),
        help=_('When True, only the single problem specified by "Link to Problem Location" is shown. '
               'When False, a panel is displayed with all problems available for peer grading.'),
        default=False,
        scope=Scope.settings
    )
    link_to_location = Reference(
        display_name=_("Link to Problem Location"),
        help=_('The location of the problem being graded. Only used when "Show Single Problem" is True.'),
        default="",
        scope=Scope.settings
    )
    graded = Boolean(
        display_name=_("Graded"),
        help=_('Defines whether the student gets credit for grading this problem. Only used when "Show Single Problem" is True.'),
        default=False,
        scope=Scope.settings
    )
    due = Date(
        help=_("Due date that should be displayed."),
        scope=Scope.settings)
    graceperiod = Timedelta(
        help=_("Amount of grace to give on the due date."),
        scope=Scope.settings
    )
    student_data_for_location = Dict(
        help=_("Student data for a given peer grading problem."),
        scope=Scope.user_state
    )
    weight = Float(
        display_name=_("Problem Weight"),
        help=_("Defines the number of points each problem is worth. If the value is not set, each problem is worth one point."),
        scope=Scope.settings, values={"min": 0, "step": ".1"},
        default=1
    )
    display_name = String(
        display_name=_("Display Name"),
        help=_("Display name for this module"),
        scope=Scope.settings,
        default=_("Peer Grading Interface")
    )
    data = String(
        help=_("Html contents to display for this module"),
        default='<peergrading></peergrading>',
        scope=Scope.content
    )


class InvalidLinkLocation(Exception):
    """
    Exception for the case in which a peer grading module tries to link to an invalid location.
    """
    pass


class PeerGradingModule(PeerGradingFields, XModule):
    """
    PeerGradingModule.__init__ takes the same arguments as xmodule.x_module:XModule.__init__
    """
    _VERSION = 1

    js = {
        'coffee': [
            resource_string(__name__, 'js/src/peergrading/peer_grading.coffee'),
            resource_string(__name__, 'js/src/peergrading/peer_grading_problem.coffee'),
            resource_string(__name__, 'js/src/javascript_loader.coffee'),
        ],
        'js': [
            resource_string(__name__, 'js/src/collapsible.js'),
        ]
    }
    js_module_name = "PeerGrading"

    css = {'scss': [resource_string(__name__, 'css/combinedopenended/display.scss')]}

    def __init__(self, *args, **kwargs):
        super(PeerGradingModule, self).__init__(*args, **kwargs)

        # Copy this to a new variable so that we can edit it if needed.
        # We need to edit it if the linked module cannot be found, so
        # we can revert to panel model.
        self.use_for_single_location_local = self.use_for_single_location

        # We need to set the location here so the child modules can use it.
        self.runtime.set('location', self.location)
        if self.runtime.open_ended_grading_interface:
            self.peer_gs = PeerGradingService(self.system.open_ended_grading_interface, self.system.render_template)
        else:
            self.peer_gs = MockPeerGradingService()

        if self.use_for_single_location_local:
            linked_descriptors = self.descriptor.get_required_module_descriptors()
            if len(linked_descriptors) == 0:
                error_msg = "Peer grading module {0} is trying to use single problem mode without "
                "a location specified.".format(self.location)
                log.error(error_msg)
                # Change module over to panel mode from single problem mode.
                self.use_for_single_location_local = False
            else:
                self.linked_problem = self.system.get_module(linked_descriptors[0])

        try:
            self.timeinfo = TimeInfo(self.due, self.graceperiod)
        except Exception:
            log.error("Error parsing due date information in location {0}".format(self.location))
            raise

        self.display_due_date = self.timeinfo.display_due_date

        try:
            self.student_data_for_location = json.loads(self.student_data_for_location)
        except Exception:  # pylint: disable=broad-except
            # OK with this broad exception because we just want to continue on any error
            pass

    @property
    def ajax_url(self):
        """
        Returns the `ajax_url` from the system, with any trailing '/' stripped off.
        """
        ajax_url = self.system.ajax_url
        if not ajax_url.endswith("/"):
            ajax_url += "/"
        return ajax_url

    def closed(self):
        return self._closed(self.timeinfo)

    def _closed(self, timeinfo):
        if timeinfo.close_date is not None and datetime.now(UTC()) > timeinfo.close_date:
            return True
        return False

    def _err_response(self, msg):
        """
        Return a HttpResponse with a json dump with success=False, and the given error message.
        """
        return {'success': False, 'error': msg}

    def _check_required(self, data, required):
        actual = set(data.keys())
        missing = required - actual
        if len(missing) > 0:
            return False, "Missing required keys: {0}".format(', '.join(missing))
        else:
            return True, ""

    def get_html(self):
        """
         Needs to be implemented by inheritors.  Renders the HTML that students see.
        @return:
        """
        if self.closed():
            return self.peer_grading_closed()
        if not self.use_for_single_location_local:
            return self.peer_grading()
        else:
            # b/c handle_ajax expects serialized data payload and directly calls peer_grading
            return self.peer_grading_problem({'location': self.link_to_location.to_deprecated_string()})['html']

    def handle_ajax(self, dispatch, data):
        """
        Needs to be implemented by child modules.  Handles AJAX events.
        @return:
        """
        handlers = {
            'get_next_submission': self.get_next_submission,
            'show_calibration_essay': self.show_calibration_essay,
            'is_student_calibrated': self.is_student_calibrated,
            'save_grade': self.save_grade,
            'save_calibration_essay': self.save_calibration_essay,
            'problem': self.peer_grading_problem,
        }

        if dispatch not in handlers:
            # This is a dev_facing_error
            log.error("Cannot find {0} in handlers in handle_ajax function for open_ended_module.py".format(dispatch))
            # This is a dev_facing_error
            return json.dumps({'error': 'Error handling action.  Please try again.', 'success': False})

        data_dict = handlers[dispatch](data)

        return json.dumps(data_dict, cls=ComplexEncoder)

    def query_data_for_location(self, location):
        student_id = self.system.anonymous_student_id
        success = False
        response = {}

        try:
            response = self.peer_gs.get_data_for_location(location, student_id)
            _count_graded = response['count_graded']
            _count_required = response['count_required']
            success = True
        except GradingServiceError:
            # This is a dev_facing_error
            log.exception("Error getting location data from controller for location %s, student %s", location, student_id)

        return success, response

    def get_progress(self):
        pass

    def get_score(self):
        max_score = None
        score = None
        weight = self.weight

        #The old default was None, so set to 1 if it is the old default weight
        if weight is None:
            weight = 1
        score_dict = {
            'score': score,
            'total': max_score,
        }
        if not self.use_for_single_location_local or not self.graded:
            return score_dict

        try:
            count_graded = self.student_data_for_location['count_graded']
            count_required = self.student_data_for_location['count_required']
        except:
            success, response = self.query_data_for_location(self.link_to_location)
            if not success:
                log.exception(
                    "No instance data found and could not get data from controller for loc {0} student {1}".format(
                        self.system.location.to_deprecated_string(), self.system.anonymous_student_id
                    ))
                return None
            count_graded = response['count_graded']
            count_required = response['count_required']
            if count_required > 0 and count_graded >= count_required:
                # Ensures that once a student receives a final score for peer grading, that it does not change.
                self.student_data_for_location = response

        score = int(count_graded >= count_required and count_graded > 0) * float(weight)
        total = float(weight)
        score_dict['score'] = score
        score_dict['total'] = total

        return score_dict

    def max_score(self):
        ''' Maximum score. Two notes:

            * This is generic; in abstract, a problem could be 3/5 points on one
              randomization, and 5/7 on another
        '''
        max_grade = None
        if self.use_for_single_location_local and self.graded:
            max_grade = self.weight
        return max_grade

    def get_next_submission(self, data):
        """
        Makes a call to the grading controller for the next essay that should be graded
        Returns a json dict with the following keys:

        'success': bool

        'submission_id': a unique identifier for the submission, to be passed back
                         with the grade.

        'submission': the submission, rendered as read-only html for grading

        'rubric': the rubric, also rendered as html.

        'submission_key': a key associated with the submission for validation reasons

        'error': if success is False, will have an error message with more info.
        """
        required = set(['location'])
        success, message = self._check_required(data, required)
        if not success:
            return self._err_response(message)
        grader_id = self.system.anonymous_student_id
        location = data['location']

        try:
            response = self.peer_gs.get_next_submission(location, grader_id)
            return response
        except GradingServiceError:
            # This is a dev_facing_error
            log.exception("Error getting next submission.  server url: %s  location: %s, grader_id: %s", self.peer_gs.url, location, grader_id)
            # This is a student_facing_error
            return {'success': False,
                    'error': EXTERNAL_GRADER_NO_CONTACT_ERROR}

    def save_grade(self, data):
        """
        Saves the grade of a given submission.
        Input:
            The request should have the following keys:
            location - problem location
            submission_id - id associated with this submission
            submission_key - submission key given for validation purposes
            score - the grade that was given to the submission
            feedback - the feedback from the student
        Returns
            A json object with the following keys:
            success: bool indicating whether the save was a success
            error: if there was an error in the submission, this is the error message
        """

        required = ['location', 'submission_id', 'submission_key', 'score', 'feedback', 'submission_flagged', 'answer_unknown']
        if data.get("submission_flagged", False) in ["false", False, "False", "FALSE"]:
            required.append("rubric_scores[]")
        success, message = self._check_required(data, set(required))
        if not success:
            return self._err_response(message)

        success, message = self._check_feedback_length(data)
        if not success:
            return self._err_response(message)

        data_dict = {k: data.get(k) for k in required}
        if 'rubric_scores[]' in required:
            data_dict['rubric_scores'] = data.getall('rubric_scores[]')
        data_dict['grader_id'] = self.system.anonymous_student_id

        try:
            response = self.peer_gs.save_grade(**data_dict)
            success, location_data = self.query_data_for_location(data_dict['location'])
            #Don't check for success above because the response = statement will raise the same Exception as the one
            #that will cause success to be false.
            response.update({'required_done': False})
            if 'count_graded' in location_data and 'count_required' in location_data and int(location_data['count_graded']) >= int(location_data['count_required']):
                response['required_done'] = True
            return response
        except GradingServiceError:
            # This is a dev_facing_error
            log.exception("Error saving grade to open ended grading service.  server url: %s", self.peer_gs.url)

            # This is a student_facing_error
            return {
                'success': False,
                'error': EXTERNAL_GRADER_NO_CONTACT_ERROR
            }

    def is_student_calibrated(self, data):
        """
        Calls the grading controller to see if the given student is calibrated
        on the given problem

        Input:
            In the request, we need the following arguments:
            location - problem location

        Returns:
            Json object with the following keys
            success - bool indicating whether or not the call was successful
            calibrated - true if the grader has fully calibrated and can now move on to grading
                       - false if the grader is still working on calibration problems
            total_calibrated_on_so_far - the number of calibration essays for this problem
                that this grader has graded
        """

        required = set(['location'])
        success, message = self._check_required(data, required)
        if not success:
            return self._err_response(message)
        grader_id = self.system.anonymous_student_id

        location = data['location']

        try:
            response = self.peer_gs.is_student_calibrated(location, grader_id)
            return response
        except GradingServiceError:
            # This is a dev_facing_error
            log.exception("Error from open ended grading service.  server url: %s, grader_id: %s, location: %s", self.peer_gs.url, grader_id, location)
            # This is a student_facing_error
            return {
                'success': False,
                'error': EXTERNAL_GRADER_NO_CONTACT_ERROR
            }

    def show_calibration_essay(self, data):
        """
        Fetch the next calibration essay from the grading controller and return it
        Inputs:
            In the request
            location - problem location

        Returns:
            A json dict with the following keys
            'success': bool

            'submission_id': a unique identifier for the submission, to be passed back
                             with the grade.

            'submission': the submission, rendered as read-only html for grading

            'rubric': the rubric, also rendered as html.

            'submission_key': a key associated with the submission for validation reasons

            'error': if success is False, will have an error message with more info.

        """

        required = set(['location'])
        success, message = self._check_required(data, required)
        if not success:
            return self._err_response(message)

        grader_id = self.system.anonymous_student_id

        location = data['location']
        try:
            response = self.peer_gs.show_calibration_essay(location, grader_id)
            return response
        except GradingServiceError:
            # This is a dev_facing_error
            log.exception("Error from open ended grading service.  server url: %s, location: %s", self.peer_gs.url, location)
            # This is a student_facing_error
            return {'success': False,
                    'error': EXTERNAL_GRADER_NO_CONTACT_ERROR}
        # if we can't parse the rubric into HTML,
        except etree.XMLSyntaxError:
            # This is a dev_facing_error
            log.exception("Cannot parse rubric string.")
            # This is a student_facing_error
            return {'success': False,
                    'error': 'Error displaying submission.  Please notify course staff.'}

    def save_calibration_essay(self, data):
        """
        Saves the grader's grade of a given calibration.
        Input:
            The request should have the following keys:
            location - problem location
            submission_id - id associated with this submission
            submission_key - submission key given for validation purposes
            score - the grade that was given to the submission
            feedback - the feedback from the student
        Returns
            A json object with the following keys:
            success: bool indicating whether the save was a success
            error: if there was an error in the submission, this is the error message
            actual_score: the score that the instructor gave to this calibration essay

        """

        required = set(['location', 'submission_id', 'submission_key', 'score', 'feedback', 'rubric_scores[]'])
        success, message = self._check_required(data, required)
        if not success:
            return self._err_response(message)

        data_dict = {k: data.get(k) for k in required}
        data_dict['rubric_scores'] = data.getall('rubric_scores[]')
        data_dict['student_id'] = self.system.anonymous_student_id
        data_dict['calibration_essay_id'] = data_dict['submission_id']

        try:
            response = self.peer_gs.save_calibration_essay(**data_dict)
            if 'actual_rubric' in response:
                rubric_renderer = combined_open_ended_rubric.CombinedOpenEndedRubric(self.system.render_template, True)
                response['actual_rubric'] = rubric_renderer.render_rubric(response['actual_rubric'])['html']
            return response
        except GradingServiceError:
            # This is a dev_facing_error
            log.exception("Error saving calibration grade")
            # This is a student_facing_error
            return self._err_response('There was an error saving your score.  Please notify course staff.')

    def peer_grading_closed(self):
        '''
        Show the Peer grading closed template
        '''
        html = self.system.render_template('peer_grading/peer_grading_closed.html', {
            'use_for_single_location': self.use_for_single_location_local
        })
        return html

    def _find_corresponding_module_for_location(self, location):
        """
        Find the peer grading module that exists at the given location.
        """
        try:
            return self.descriptor.system.load_item(location)
        except ItemNotFoundError:
            # The linked problem doesn't exist.
            log.error("Problem {0} does not exist in this course.".format(location))
            raise
        except NoPathToItem:
            # The linked problem does not have a path to it (ie is in a draft or other strange state).
            log.error("Cannot find a path to problem {0} in this course.".format(location))
            raise

    def peer_grading(self, _data=None):
        '''
        Show a peer grading interface
        '''

        # call problem list service
        success = False
        error_text = ""
        problem_list = []
        try:
            problem_list_dict = self.peer_gs.get_problem_list(self.course_id, self.system.anonymous_student_id)
            success = problem_list_dict['success']
            if 'error' in problem_list_dict:
                error_text = problem_list_dict['error']

            problem_list = problem_list_dict['problem_list']

        except GradingServiceError:
            # This is a student_facing_error
            error_text = EXTERNAL_GRADER_NO_CONTACT_ERROR
            log.error(error_text)
            success = False
        # catch error if if the json loads fails
        except ValueError:
            # This is a student_facing_error
            error_text = "Could not get list of problems to peer grade.  Please notify course staff."
            log.error(error_text)
            success = False
        except Exception:
            log.exception("Could not contact peer grading service.")
            success = False

        good_problem_list = []
        for problem in problem_list:
            problem_location = problem['location']
            try:
                descriptor = self._find_corresponding_module_for_location(problem_location)
            except (NoPathToItem, ItemNotFoundError):
                continue
            if descriptor:
                problem['due'] = descriptor.due
                grace_period = descriptor.graceperiod
                try:
                    problem_timeinfo = TimeInfo(problem['due'], grace_period)
                except Exception:
                    log.error("Malformed due date or grace period string for location {0}".format(problem_location))
                    raise
                if self._closed(problem_timeinfo):
                    problem['closed'] = True
                else:
                    problem['closed'] = False
            else:
                # if we can't find the due date, assume that it doesn't have one
                problem['due'] = None
                problem['closed'] = False
            good_problem_list.append(problem)

        ajax_url = self.ajax_url
        html = self.system.render_template('peer_grading/peer_grading.html', {
            'ajax_url': ajax_url,
            'success': success,
            'problem_list': good_problem_list,
            'error_text': error_text,
            # Checked above
            'staff_access': False,
            'use_single_location': self.use_for_single_location_local,
        })

        return html

    def peer_grading_problem(self, data=None):
        '''
        Show individual problem interface
        '''
        if data is None or data.get('location') is None:
            if not self.use_for_single_location_local:
                # This is an error case, because it must be set to use a single location to be called without get parameters
                # This is a dev_facing_error
                log.error(
                    "Peer grading problem in peer_grading_module called with no get parameters, but use_for_single_location is False.")
                return {'html': "", 'success': False}
            problem_location = self.link_to_location

        elif data.get('location') is not None:
            problem_location = self.course_id.make_usage_key_from_deprecated_string(data.get('location'))

        self._find_corresponding_module_for_location(problem_location)

        ajax_url = self.ajax_url
        html = self.system.render_template('peer_grading/peer_grading_problem.html', {
            'view_html': '',
            'problem_location': problem_location,
            'course_id': self.course_id,
            'ajax_url': ajax_url,
            # Checked above
            'staff_access': False,
            'use_single_location': self.use_for_single_location_local,
        })

        return {'html': html, 'success': True}

    def get_instance_state(self):
        """
        Returns the current instance state.  The module can be recreated from the instance state.
        Input: None
        Output: A dictionary containing the instance state.
        """

        state = {
            'student_data_for_location': self.student_data_for_location,
        }

        return json.dumps(state)

    def _check_feedback_length(self, data):
        feedback = data.get("feedback")
        if feedback and len(feedback) > MAX_ALLOWED_FEEDBACK_LENGTH:
            return False, "Feedback is too long, Max length is {0} characters.".format(
                MAX_ALLOWED_FEEDBACK_LENGTH
            )
        else:
            return True, ""

    def validate(self):
        """
        Message for either error or warning validation message/s.

        Returns message and type. Priority given to error type message.
        """
        return self.descriptor.validate()


class PeerGradingDescriptor(PeerGradingFields, RawDescriptor):
    """
    Module for adding peer grading questions
    """
    mako_template = "widgets/raw-edit.html"
    module_class = PeerGradingModule
    filename_extension = "xml"

    has_score = True
    always_recalculate_grades = True

    #Specify whether or not to pass in open ended interface
    needs_open_ended_interface = True

    metadata_translations = {
        'is_graded': 'graded',
        'attempts': 'max_attempts',
        'due_data': 'due'
    }

    @property
    def non_editable_metadata_fields(self):
        non_editable_fields = super(PeerGradingDescriptor, self).non_editable_metadata_fields
        non_editable_fields.extend([PeerGradingFields.due, PeerGradingFields.graceperiod])
        return non_editable_fields

    def get_required_module_descriptors(self):
        """
        Returns a list of XModuleDescriptor instances upon which this module depends, but are
        not children of this module.
        """

        # If use_for_single_location is True, this is linked to an open ended problem.
        if self.use_for_single_location:
            # Try to load the linked module.
            # If we can't load it, return empty list to avoid exceptions on progress page.
            try:
                linked_module = self.system.load_item(self.link_to_location)
                return [linked_module]
            except (NoPathToItem, ItemNotFoundError):
                error_message = ("Cannot find the combined open ended module "
                                 "at location {0} being linked to from peer "
                                 "grading module {1}").format(self.link_to_location, self.location)
                log.error(error_message)
                return []
        else:
            return []

    # Proxy to PeerGradingModule so that external callers don't have to know if they're working
    # with a module or a descriptor
    closed = module_attr('closed')
    get_instance_state = module_attr('get_instance_state')
    get_next_submission = module_attr('get_next_submission')
    graded = module_attr('graded')
    is_student_calibrated = module_attr('is_student_calibrated')
    peer_grading = module_attr('peer_grading')
    peer_grading_closed = module_attr('peer_grading_closed')
    peer_grading_problem = module_attr('peer_grading_problem')
    peer_gs = module_attr('peer_gs')
    query_data_for_location = module_attr('query_data_for_location')
    save_calibration_essay = module_attr('save_calibration_essay')
    save_grade = module_attr('save_grade')
    show_calibration_essay = module_attr('show_calibration_essay')
    use_for_single_location_local = module_attr('use_for_single_location_local')
    _find_corresponding_module_for_location = module_attr('_find_corresponding_module_for_location')

    def validate(self):
        """
        Validates the state of this instance. This is the override of the general XBlock method,
        and it will also ask its superclass to validate.
        """
        validation = super(PeerGradingDescriptor, self).validate()
        validation = StudioValidation.copy(validation)

        i18n_service = self.runtime.service(self, "i18n")

        validation.summary = StudioValidationMessage(
            StudioValidationMessage.ERROR,
            i18n_service.ugettext(
                "ORA1 is no longer supported. To use this assessment, "
                "replace this ORA1 component with an ORA2 component."
            )
        )
        return validation
