from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class CRUD:   
    def add(self, resource):
        db.session.add(resource)
        return db.session.commit()   

    def update(self):
        return db.session.commit()

    def delete(self, resource):
        db.session.delete(resource)
        return db.session.commit()

"""
Global Flask Application Setting

set FLASK_CONFIG to 'development
 """

import os

class Config:
    # If not set fall back to production for safety
    FLASK_ENV =  os.getenv('FLASK_ENV', 'production')
    # Set FLASK_SECRET on your production Environment
    SECRET_KEY = os.getenv('FLASK_SECRET', 'Secret')

    APP_DIR = os.path.dirname(__file__)
    ROOT_DIR = os.path.dirname(APP_DIR)

    HOST = '0.0.0.0'
    PORT = '5000'
    DEBUG = True

    LOG_PATH = os.path.abspath(APP_DIR)+"/log"

    MYSQL_DATABASE_USERNAME='user'
    MYSQL_DATABASE_PASSWORD='userpassword'
    MYSQL_DATABASE_NAME='database'
    MYSQL_DATABASE_HOST='localhost'
    MYSQL_PORT=os.getenv('MYSQL_PORT','33306')

    SQLALCHEMY_ECHO = True
    SQLALCHEMY_TRACK_MODIFICATIONS = True
    SQLALCHEMY_DATABASE_URI = "mysql+pymysql://{DB_USER}:{DB_PASS}@{DB_ADDR}:{DB_PORT}/{DB_NAME}?charset=utf8"
    SQLALCHEMY_DATABASE_URI = SQLALCHEMY_DATABASE_URI.format(DB_USER=MYSQL_DATABASE_USERNAME,
                                                             DB_PASS=MYSQL_DATABASE_PASSWORD,
                                                             DB_ADDR=MYSQL_DATABASE_HOST,
                                                             DB_PORT=MYSQL_PORT,
                                                             DB_NAME=MYSQL_DATABASE_NAME)

from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.exc import SQLAlchemyError
from marshmallow_jsonapi.flask import Schema
from marshmallow_jsonapi import fields
from marshmallow import validate

from app.api.database import db
from app.api.database import CRUD

class Books(db.Model, CRUD):
    __table_args__ = {'mysql_collate': 'utf8_general_ci'}
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(250), unique=True, nullable=False)
    creation_time = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False)
    is_rent = db.Column(db.Boolean, default=True, nullable=False)
    
    def __init__(self, name, is_rent):
        self.name = name
        self.is_rent = is_rent

class BooksSchema(Schema):
    not_blank = validate.Length(min=1, error='Field cannot be blank')
    id = fields.Integer(dump_only=True)
    name = fields.String(validate=not_blank)
    is_rent = fields.Boolean()
    #self links
    def get_top_level_links(self, data, many):
        if many:
            self_link = "/api/books"
        else:
            self_link = "/api/books/{}".format(data['id'])
        return {'self': self_link}

    class Meta:
        type_ = 'books'

from flask import jsonify
from flask import make_response
from flask import Blueprint

from flask_restful import Resource
from flask_restful import Api
from flask_restful import reqparse
from flask_restful import abort
from flask_restful import fields
from flask_restful import marshal_with

from sqlalchemy.exc import IntegrityError
from marshmallow import ValidationError
from app.books.models import Books
from app.books.models import BooksSchema
from app.api.database import db

books_api = Blueprint('books', "Book's API")
schema = BooksSchema()
book_fields = {
    'id': fields.Integer,
	'name': fields.String,
    'is_rent': fields.Boolean
}
class BookItem(Resource):
	parser = reqparse.RequestParser()
	parser.add_argument('name', type=str, help="book's name",location='json')
	parser.add_argument('is_rent', type=int, help='is it rentable?',location='json')
	body = ''
	status_code = 501 # NOT_IMPLEMENTED
	def get(self, book_id):
		book_query = Books.query.get_or_404(book_id)
		book = schema.dump(book_query).data
		return book

	def patch(self, book_id):
		args = self.parser.parse_args()
		book = Books.query.get_or_404(book_id)
		for key, value in args.items():
			setattr(book, key, value)
		try:
			book.update()
			self.body = jsonify(schema.dump(book).data)
			self.status_code = 200 # OK
		except IntegrityError as error:
			db.session.rollback()
			error_message = str(error) 
			self.body = jsonify({"error": error_message, "type":"IntegrityError"})
			if "Duplicate entry" in error_message:
				self.status_code = 409 # CONFLICT
			else:
				self.status_code = 400 # BAD REQUEST
		finally:
			response = (self.body, self.status_code.value)
			response = make_response(response)

		return response

	def delete(self, book_id):
		return {'book_id': book_id, 'method':'delete'}

class BooksList(Resource):
	parser = reqparse.RequestParser()
	parser.add_argument('name', required=True, type=str, help="book's name",location='json')
	parser.add_argument('is_rent', type=int, help='is it rentable?',location='json')
	body = ''
	status_code = 501

	def get(self):
		books_query = Books.query.all()
		results = schema.dump(books_query, many=True).data
		self.body = jsonify(results)
		self.status_code = 200
		response = (self.body, self.status_code)
		return make_response(response)

	def post(self):
		args = self.parser.parse_args()
		book = Books(name=args['name'],
					is_rent=args['is_rent'])
		try:
			book.add(book) 
			query = Books.query.get(book.id)
			self.body = jsonify(schema.dump(query).data)
			self.status_code = 201

		except IntegrityError as error:
			db.session.rollback()
			import os
			error_message = str(error) 
			self.body = jsonify({"error": str(error), "type":"IntegrityError"})
			if "Duplicate entry" in error_message:
				self.status_code = 409
			else:
				self.status_code = 400
		finally:
			response = (self.body, self.status_code.value)
			response = make_response(response)

		return response

from app.books.views import books_api
from app.books.views import BookItem
from app.books.views import BooksList
from flask_restful import Api

api = Api(books_api)
api.add_resource(BookItem, '/<int:book_id>')
api.add_resource(BooksList, '/')

import os
from flask import Flask, current_app, send_file
from app.api import books_api

from logging.config import dictConfig
from app.books.models import db
from app.config import Config
import logging

def create_app(config_filename):
    if 'TRAVIS_CI' not in os.environ:
        dictConfig({
            'version':1,
            'formatters': {
                'default': {
                    'format': '%(asctime)s] [%(levelname)s] [%(module)s:%(lineno)d]\n %(message)s',
                },
            },
            'handlers': {
                'file_handler': {
                    'class': 'logging.FileHandler',
                    'filename': Config.LOG_PATH + '/app.log',
                    'formatter': 'default',
                },
            },
            'root': {
                'level': 'INFO',
                'handlers': ['file_handler']
            }
        })
    
    app = Flask(__name__)
    app.config.from_object(config_filename)
    db.init_app(app)
    
    app.register_blueprint(books_api, url_prefix='/api/books')


    app.logger.info('>>> {}'.format(Config.FLASK_ENV))
    return app

import os

from app import create_app

app = create_app('app.config.Config')

if __name__ == '__main__':
    app.run(host=app.config['HOST'],
            port=app.config['PORT'],
            debug=app.config['DEBUG'])