import io
import base64
import os
from PIL import Image
from flask import request,jsonify
from app.models.genre import Genre
from app.models.program import Program
from werkzeug.datastructures import FileStorage
from app.services.program_service import ProgramService
from flask_restx import Resource, reqparse, abort, Namespace, Model, fields



# Create a namespace for programs
UPLOAD_FOLDER = 'uploads'


program_namespace = Namespace('programs', path='/programs')

genre_model = program_namespace.model('Genre', {
    'name': fields.String(required=True),
    # Add other genre fields as needed
})

# Parser for handling file uploads
upload_parser = reqparse.RequestParser()
upload_parser.add_argument('image', location='files', type=FileStorage, required=True)


program_model = program_namespace.model("Program",{
    "name":fields.String(required=True),
    "summary":fields.String(required=True),
    "language":fields.String(required=True),
    'genre': fields.List(fields.String, required=True),
    # "genre":fields.List(default=['comedy','drama']),
    "officialSite":fields.String(required=True),
    "program_type":fields.String(required=True,default="scripted"),
    "status": fields.String(required=True,default="ended"),
    "runtime": fields.Integer(required=True),
    "premiered": fields.String(required=True,default="2023-10-03"),
    "image": fields.Raw(
        required=True,
        description='Image file',
        type='file',
        data_format='binary'
    )
    })

@program_namespace.route('/<string:program_id>')
class ProgramResource(Resource):
    def get(self, program_id):
        self.service = ProgramService()
        program = self.service.get_program_by_id(program_id)
        if not program:
            return abort(404, message="Program not found")
        return program

    @program_namespace.expect(program_model)
    def put(self, program_id):
        parser = reqparse.RequestParser()
        parser.add_argument("name", type=str)
        parser.add_argument("summary", type=str)
        parser.add_argument("language", type=str)
        parser.add_argument("genre", type=list)
        parser.add_argument("officialSite", type=str)
        parser.add_argument("program_type", type=str, choices=["scripted", "reality", "comedy", "news"])
        parser.add_argument("status", type=str, choices=["ongoing", "ended", "upcoming"])
        parser.add_argument("runtime", type=int)
        parser.add_argument("premiered", type=str)
        parser.add_argument("image", type=dict)

        data = parser.parse_args()
        updated_program = self.service.update_program(program_id, data)
        if not updated_program:
            return abort(404, message="Program not found")
        return updated_program

    def delete(self, program_id):
        self.service = ProgramService()
        if self.service.delete_program(program_id):
            return {"message": "Program deleted"}, 204
        return abort(404, message="Program not found")

@program_namespace.route('/')
class ProgramListResource(Resource):

    def get(self):
        self.service = ProgramService()
        programs = self.service.get_all_programs()
        return programs

    @program_namespace.expect(program_model)
    # @program_namespace.marshal_with(program_model)
    def post(self):
        self.service = ProgramService()
        
        args = upload_parser.parse_args()

        # create upload folder
        uploaded_file = args['image']
        

        # Save the uploaded file to your desired location
        file_path = f'{UPLOAD_FOLDER}/Programs/{uploaded_file.filename}'
        uploaded_file.save(file_path)

        parser = reqparse.RequestParser()
        parser.add_argument("name", type=str, required=True)
        parser.add_argument("summary", type=str)
        parser.add_argument("language", type=str)
        parser.add_argument("genre", type=list)
        parser.add_argument("officialSite", type=str)
        parser.add_argument("program_type", type=str, choices=["scripted", "reality", "comedy", "news"])
        parser.add_argument("status", type=str, choices=["ongoing", "ended", "upcoming"])
        parser.add_argument("runtime", type=int)
        parser.add_argument("premiered", type=str)
        parser.add_argument("image", type=dict)  

        

        data = parser.parse_args()
        data['image'] = {
            "size": os.path.getsize(file_path),
            "path":file_path
        }

        print("Image Data: ",data)
        
        # new_program = self.service.create_program(data)
        
        return {"message":"Program Created Success"},201


    def delete(self):
        self.service = ProgramService()
        deleted_count = self.service.delete_all_programs()
        if deleted_count > 0:
            return {"message": f"{deleted_count} programs deleted"}, 204
        return abort(404, message="No programs found")