from django.shortcuts import render, redirect
from django.http import JsonResponse
from ninja import NinjaAPI, Schema
import requests
import json
from decouple import config
import openai
from django.views import View
from django.contrib import messages
from django.contrib.auth import login
from django.contrib.auth.models import User
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status




# Create your views here.

def home(request):
    return render(request, 'home/index.html')

def about(request):
    return render(request, 'home/about.html')

def services(request):
    return render(request, 'home/services.html')

def bio(request):
    return render(request, 'home/bio.html')

def contact(request):
    return render(request, 'home/contact.html')
    
#Les fonctions
# open ai
def api_call_view(request):
    if request.method == 'POST':
        data = json.loads(request.body)
        prompt = data.get('prompt')
        response = openai.Completion.create(
            engine="text-davinci-002",
            prompt=prompt,
            max_tokens=150,
            n=1,
            stop=None,
            temperature=0.5
        )
        return JsonResponse({'response': response.choices[0].text.strip()})
    else:
        return JsonResponse({'error': 'Method not allowed'}, status=405)
        
#wordpress GraphQl
class WordPressGraphQLView(View):
    def get(self, request):
        url = 'https://jolyagence.com/graphql'
        query = """
        query {
            posts {
                nodes {
                    id
                    title
                    content
                }
            }
            pages {
                nodes {
                    id
                    title
                    content
                }
            }
        }
        """

        try:
            response = requests.post(url, json={'query': query})
            response.raise_for_status()
        except requests.exceptions.RequestException as e:
            return render(request, 'home/error.html', {'error': str(e)})

        data = response.json()

        if 'errors' in data:
            return render(request, 'home/error.html', {'error': data['errors']})

        posts = data['data']['posts']['nodes']
        pages = data['data']['pages']['nodes']


        return render(request, 'home/posts.html', {'posts': posts, 'pages': pages})

#authent wordpress        
class WordPressLoginView(View):
    def get(self, request):
        return render(request, 'home/login.html')

    def post(self, request):
        username = request.POST.get('username')
        password = request.POST.get('password')
        url = 'https://jolyagence.com/graphql'

        query = """
        mutation Login($username: String!, $password: String!) {
            login(input: {username: $username, password: $password}) {
                authToken
                user {
                    id
                    name
                }
            }
        }
        """
        
        variables = {
            'username': username,
            'password': password
        }

        headers = {
            'Content-Type': 'application/json'
        }

        try:
            response = requests.post(url, json={'query': query, 'variables': variables}, headers=headers)
            response.raise_for_status()
        except requests.exceptions.RequestException as e:
            messages.error(request, f'Error: {e}')
            return redirect('login')

        response_data = response.json()

        if 'errors' in response_data:
            messages.error(request, 'Invalid login credentials')
            return redirect('login')

        auth_token = response_data['data']['login']['authToken']
        request.session['jwt_token'] = auth_token

        # Authentifier l'utilisateur sur Django également
        user, created = User.objects.get_or_create(username=username)
        login(request, user)
        messages.success(request, 'Successfully logged in')
        return redirect('/about/')  # Rediriger vers une page d'accueil après connexion
        

#pages protégées
class ProtectedView(View):
    def get(self, request):
        token = request.session.get('jwt_token')
        if not token:
            messages.error(request, 'You need to be logged in to access this page.')
            return redirect('login')

        # Utilisez le jeton JWT pour des requêtes futures à l'API WordPress
        headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }
        
        query = """
        query {
            posts {
                nodes {
                    id
                    title
                    content
                }
            }
            pages {
                nodes {
                    id
                    title
                    content
                }
            }
        }
        """
        
        try:
            response = requests.post('https://jolyagence.com/graphql', json={'query': query}, headers=headers)
            response.raise_for_status()
            response_data = response.json()
        except requests.exceptions.RequestException as e:
            messages.error(request, f'Error: {e}')
            return redirect('login')

        if 'errors' in response_data:
            messages.error(request, f'GraphQL errors: {response_data["errors"]}')
            return redirect('login')

        posts = response_data['data']['posts']['nodes']
        pages = response_data['data']['pages']['nodes']
        
        return render(request, 'home/protected.html', {'posts': posts, 'pages': pages})
        
#non identifié 
def csrf_failure(request, reason=""):
    context = {'message': 'CSRF verification failed. Please try logging in again.'}
    return render(request, 'home/csrf_failure.html', context)
    
#Wordpress views enregistrement
class WordPressRegisterView(View):
    def get(self, request):
        return render(request, 'home/register.html')

    def post(self, request):
        username = request.POST.get('username')
        email = request.POST.get('email')
        password = request.POST.get('password')
        url = 'https://jolyagence.com/graphql'

        query = """
        mutation RegisterUser($username: String!, $email: String!, $password: String!) {
            registerUser(input: {username: $username, email: $email, password: $password}) {
                user {
                    id
                    name
                    email
                }
            }
        }
        """
        
        variables = {
            'username': username,
            'email': email,
            'password': password
        }

        headers = {
            'Content-Type': 'application/json'
        }

        try:
            response = requests.post(url, json={'query': query, 'variables': variables}, headers=headers)
            response.raise_for_status()
            response_data = response.json()
        except requests.exceptions.RequestException as e:
            messages.error(request, f'Error: {e}')
            return redirect('register')

        if 'errors' in response_data:
            messages.error(request, response_data['errors'][0]['message'])
            return redirect('register')

        messages.success(request, 'Account successfully created. Please log in.')
        return redirect('login')
        
#mycred
class MyCredPointsView(APIView):
    template_name = 'home/mescredits.html'

    def get(self, request, format=None):
        user_id = request.query_params.get('user_id')
        if not user_id:
            return render(request, self.template_name, {'error': "User ID is required"})

        access_key = ")j=;^6LJXY2%hX8"
        type = "get"
        ctype = "type_example"
        reference = "reference_example"
        amount = "100"
        entry = "entry_example"

        url = "https://www.jolyagence.com/mycred/v1/points"
        data = {
            "access_key": access_key,
            "user_id": user_id,
            "type": type,
            "ctype": ctype,
            "reference": reference,
            "amount": amount,
            "entry": entry
        }

        try:
            response = requests.post(url, data=data)  # Use data instead of json to send form-encoded data
            response.raise_for_status()
            try:
                points = response.json()
            except ValueError:
                # Log raw response if JSON decoding fails
                return render(request, self.template_name, {
                    'error': f"Failed to decode JSON response: {response.text}",
                    'user_id': user_id
                })
            return render(request, self.template_name, {'points': points, 'user_id': user_id})
        except requests.exceptions.HTTPError as err:
            error = f"HTTP error occurred: {err}"
            return render(request, self.template_name, {'error': error})
        except Exception as err:
            error = f"Other error occurred: {err}"
            return render(request, self.template_name, {'error': error})

class MyCredLogsView(View):
    def get(self, request):
        user_id = request.GET.get('user_id')
        if not user_id:
            return JsonResponse({'error': 'user_id parameter is required'}, status=400)
        try:
            response = requests.get(
                f'{MYCRED_LOG_ENDPOINT}?user={user_id}',
                headers={'Authorization': f'Bearer {MYCRED_API_KEY}'}
            )
            response.raise_for_status()
            data = response.json()
            return JsonResponse(data)
        except requests.RequestException as e:
            return JsonResponse({'error': str(e)}, status=500)