from flask import request, jsonify
from flask_classful import FlaskView, route
from werkzeug.datastructures import MultiDict
from flask_jwt_extended import jwt_required

from app.sql.common import db, Session
from app.server.helpers import parse_search_args, parse_sort_args

class CrudView(FlaskView):
  # to subclass CrudView, specify the model + form:
  # model = Collection
  # form = CollectionForm
  index_all = True
  excluded_methods = ['on_index', 'on_show', 'on_create', 'on_update', 'on_destroy']
  default_sort = "id"
  default_order = "asc"

  # implement these methods:
  def where(self, query, args):
    return query
  def on_index(self, session, data):
    return data
  def on_show(self, session, data):
    return data
  def on_create(self, session, form, item):
    pass
  def on_update(self, session, form, item):
    pass
  def on_destroy(self, session, item):
    pass

  @jwt_required()
  def index(self):
    """
    List all {model}s
    """
    session = Session()
    if self.index_all:
      items = session.query(self.model).all()
    else:
      offset, limit = parse_search_args(request.args)
      sort, order, order_by, order_by_id = parse_sort_args(request.args, self.model, self.default_sort, self.default_order)
      query = session.query(self.model)
      query = self.where(query, request.args)
      if order_by_id is not None:
        query = query.order_by(order_by, order_by_id)
      else:
        query = query.order_by(order_by)
      items = query.offset(offset).limit(limit).all()

    res = self.on_index(session, {
      'status': 'ok',
      'res': [ item.toJSON() for item in items ],
    })
    session.close()
    return jsonify(res)

  @jwt_required()
  def get(self, id: int):
    """
    Fetch a single {model}.
    """
    session = Session()
    item = session.query(self.model).get(id)
    if not item:
      session.close()
      return jsonify({
        'status': 'error',
        'error': 'item not found'
      })
    result = self.on_show(session, {
      'status': 'ok',
      'res': item.toFullJSON() if hasattr(item, 'toFullJSON') else item.toJSON(),
    })
    session.close()
    return jsonify(result)

  @jwt_required()
  def post(self):
    """
    Create a new {model}.

    * JSON params: {jsonparams}
    """
    session = Session()
    raw_form = MultiDict(request.json) if request.json is not None else request.form
    form = self.form(raw_form)
    if form.validate():
      item = self.model()
      form.populate_obj(item)
      self.on_create(session, raw_form, item)
      session.add(item)
      session.commit()
      res = {
        'status': 'ok',
        'res': item.toJSON(),
      }
    else:
      res = {
        'error': 'error',
        'errors': form.errors,
      }
    session.close()
    return jsonify(res)

  @jwt_required()
  def put(self, id: int):
    """
    Update a {model}.

    * JSON params: {jsonparams}
    """
    session = Session()
    item = session.query(self.model).get(id)
    if item:
      raw_form = MultiDict(request.json) if request.json is not None else request.form
      form = self.form(raw_form, obj=item)
      # print(item.toJSON())
      form.populate_obj(item)
      if form.validate():
        self.on_update(session, raw_form, item)
        session.add(item)
        session.commit()
        res = {
          'status': 'ok',
          'res': item.toJSON(),
        }
      else:
        print(form.errors)
        res = {
          'status': 'error',
          'error': form.errors,
        }
    else:
      res = {
        'status': 'error',
        'error': 'not found',
      }
    session.close()
    return jsonify(res)

  @jwt_required()
  def delete(self, id: int):
    """
    Delete a {model}.
    """
    session = Session()
    item = session.query(self.model).get(id)
    if item:
      self.on_destroy(session, item)
      session.delete(item)
      session.commit()
      res = {
        'status': 'ok',
        'id': id,
      }
    else:
      res = {
        'status': 'error',
        'error': 'not found',
      }
    session.close()
    return jsonify(res)