#!/usr/bin/python

import json

from flask import Flask, jsonify, request
from flask.json import JSONEncoder

from DLIQueryResolver import QueryResolver
from DLI_ObjectResolver import DLIObject, DLIRelation
from logger import dlilogger


class MyJSONEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, DLIObject):
            return obj.__dict__
        if isinstance(obj, DLIRelation):
            return obj.__dict__
        return super(MyJSONEncoder, self).default(obj)


app = Flask(__name__)
app.debug = False
app.json_encoder = MyJSONEncoder

host = "http://localhost:8983/solr/DLIF-index-cleaned"
base_dnet_url = "http://localhost:8080/dli"


# q = QueryResolver("http://localhost:8983/solr/DLIF-index-cleaned_shard1_replica1")

class InvalidUsage(Exception):
    status_code = 400

    def __init__(self, message, status_code=None, payload=None):
        Exception.__init__(self)
        self.message = message
        if status_code is not None:
            self.status_code = status_code
        self.payload = payload

    def to_dict(self):
        rv = dict(self.payload or ())
        rv['message'] = self.message
        return rv


# Routes
@app.route('/')
def root():
    return app.send_static_file('index.html')


@app.route('/<path:path>')
def static_proxy(path):
    # send_static_file will guess the correct MIME type
    return app.send_static_file(path)


@app.route('/api/item/<path:identifier>', methods=['post', 'get'])
def getItem(identifier):
    if identifier:
        q = QueryResolver(host, base_dnet_url)
        return jsonify(result=q.get_item(identifier))
    else:
        raise InvalidUsage('This view is gone', status_code=410)


@app.route('/api/stats/', methods=['post', 'get'])
def stats():
    q = QueryResolver(host, base_dnet_url)
    return jsonify(stats=q.get_stats())


@app.route('/api/ds_info/', methods=['post', 'get'])
def info():
    q = QueryResolver(host, base_dnet_url)
    if 'id' in request.form:
        id = request.form['id']
        name = request.form['name']
        result = q.get_ds_info(id, name)
        return jsonify(info=result)
    result = q.get_all_ds()
    return jsonify(info=result)


@app.route('/api/stats_detail/', methods=['post', 'get'])
def stats_detail():
    q = QueryResolver(host, base_dnet_url)
    return jsonify(stats=q.get_stats_detail())


@app.route('/api/post/', methods=['post', 'get'])
def query_post():
    action = None
    query = None
    only_result = False
    filter_query = None
    start = 0
    if 'action' in request.form:
        action = request.form['action']
    if 'query' in request.form:
        query = request.form['query']
    if 'only_result' in request.form:
        only_result = True

    if 'browse_field' in request.form:
        try:
            filter_query = json.loads(request.form['browse_field'])
        except:
            app.logger.error("Unable to parse browse_field, current value %s" % request.form['browse_field'])

    if 'start' in request.form:
        start = int(request.form['start'])

    if action == 'query' and query is not None:
        q = QueryResolver(host, base_dnet_url)
        try:
            result = q.query(q=query, browse_fields=["entitytype", "provenance", "publisher"], start=start, only_result=only_result,
                             filter_query=filter_query)
        except Exception as e:
            print e
        return jsonify(result=result)
    else:
        return jsonify(error={'error_code': 'an error occur during query on server'})


if __name__ == '__main__':
    app.logger.addHandler(dlilogger)
    app.run(debug=False, host='0.0.0.0', processes=5)