<?php

defined('BASEPATH') or exit('No direct script access allowed');

class Donation extends MY_Controller
{
    public function __construct()
    {
        parent::__construct();

        $no_logged_methods = array();

        if (empty($this->session->logged) && !in_array($this->router->fetch_method(), $no_logged_methods)) {
            $this->session->set_flashdata('show_login_form', true);
            redirect('engine/error?http_code=403');
        }
    }

    public function create_order()
    {
        $package = $this->input->post('package', true);
        $processor = $this->input->post('processor', true);

        // Vérification de la validité du package et du processeur
        $packages = $this->config->item('packages');
        $processors = $this->config->item('processors');

        if (!isset($packages[$package])) {
            return $this->return_error('Invalid package or processor.');
        }

        $user_id = $this->session->userdata('id');
        
        // Vérifier si l'utilisateur peut utiliser ce moyen de paiement
        $allowed_methods = $this->get_allowed_payment_methods($user_id);
        if (!in_array($processor, $allowed_methods)) {
            return $this->return_error('Payment method not available.');
        }

        $amount = $packages[$package]['amount'];
        $product_id = $packages[$package]['product_id'];
        $email = $this->session->userdata('email');
        $username = $this->session->userdata('nickname');

        // Mapping des processeurs vers les méthodes de paiement
        $payment_method_mapping = array(
            'paypal' => 'paypal',
            'revolut' => 'revolut',
            'mercuryo' => 'mercuryo',
            'onramp' => 'onramp',
            'cc3ds' => 'snappy',
            'crypto' => 'crypto',
            'onramp2' => 'onramp2'
        );

        // Vérifier si le processeur est supporté par la nouvelle API
        if (isset($payment_method_mapping[$processor])) {
            $payment_method = $payment_method_mapping[$processor];
            
            // Données à envoyer à l'API
            $data = array(
                'product_id' => $product_id,
                'quantity' => 1,
                'email' => $email,
                'username' => $username,
                'payment_method' => $payment_method
            );

            $jsonData = json_encode($data);
            $api = 'https://secure.yggboutique.com/wp-json/custom/v1/generate-checkout-token/';
            
            $ch = curl_init($api);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, $jsonData);
            curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));

            $output = curl_exec($ch);
            $httpStatusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
            curl_close($ch);

            if ($output === false || $httpStatusCode != 200) {
                return $this->return_error('Erreur lors de la génération du lien de paiement.');
            }

            $response = json_decode($output, true);

            if (json_last_error() !== JSON_ERROR_NONE || !isset($response['success']) || !$response['success']) {
                return $this->return_error('Réponse invalide de l\'API de paiement.');
            }

            if (!isset($response['data']['checkout_url'])) {
                return $this->return_error('URL de checkout manquante dans la réponse API.');
            }

            return $this->output->set_content_type('application/json')
                ->set_output(json_encode(array(
                    'status' => 'success',
                    'invoice_page' => $response['data']['checkout_url']
                )));
        }

    }


    public function get_payment_modal()
    {        
        // Récupération des paramètres du navigateur (6 paramètres pour masquer le critère)
        $timezone = $this->input->post('timezone');
        $language = $this->input->post('language');
        $user_agent = $this->input->post('user_agent');
        $screen_resolution = $this->input->post('screen_resolution');
        $color_depth = $this->input->post('color_depth');
        $platform = $this->input->post('platform');

        $user_id = $this->session->userdata('id');
        
        // Vérifier si l'utilisateur a des restrictions (blacklist ou critères actuels)
        $show_limited_methods = $this->check_user_payment_restrictions_with_browser_data(
            $user_id, $timezone, $language, $user_agent, $screen_resolution, $color_depth, $platform
        );

        // Définir les moyens de paiement à afficher
       /*** if ($show_limited_methods) {
            $payment_methods = [
                'crypto' => [
                    'name' => 'Cryptomonnaies',
                    'icon' => 'crypto',
                    'processor' => 'crypto'
                ],
                'onramp' => [
                    'name' => 'Carte bancaire <span style="color: #c1c1c1;text-transform: uppercase;font-size: 12px;padding-left: 7px;">On-ramp</span>',
                    'icon' => 'onramp',
                    'processor' => 'onramp',
                    'recommended' => true
                ]
            ];
        } else {
            $payment_methods = [
                'paypal' => [
                    'name' => 'PayPal et carte bancaire',
                    'icon' => 'paypal',
                    'processor' => 'paypal',
                    'recommended' => true
                ],
                'onramp' => [
                    'name' => 'Carte bancaire <span style="color: #c1c1c1;text-transform: uppercase;font-size: 12px;padding-left: 7px;">On-ramp</span>',
                    'icon' => 'credit-card',
                    'processor' => 'onramp',
                    'recommended' => true
                ],
                'cc3ds' => [
                    'name' => 'Carte bancaire 3DS <span style="color: #c1c1c1;text-transform: uppercase;font-size: 12px;padding-left: 7px;">For 3D Secure cards only</span>',
                    'icon' => 'credit-card',
                    'processor' => 'cc3ds'
                ],
                'crypto' => [
                    'name' => 'Cryptomonnaies',
                    'icon' => 'crypto',
                    'processor' => 'crypto'
                ]
            ];
        }
 */
        $payment_methods = array(
            'onramp' => [
            'name' => 'Carte bancaire',
            'icon' => 'credit-card',
            'processor' => 'onramp',
            'recommended' => true
        ],
        'crypto' => [
            'name' => 'Cryptomonnaies',
            'icon' => 'crypto',
            'processor' => 'crypto',
            'recommended' => true
        ]); 

        // Générer le HTML des moyens de paiement
        $payment_list_html = '';
        foreach ($payment_methods as $method) {
            $recommended = isset($method['recommended']) && $method['recommended'] ?
                '<span style="color: #61c941;text-transform: uppercase;font-size: 11px;">Recommandé</span>' : '';
            
            $payment_list_html .= '<li class="payment-list-item" data-processor="' . $method['processor'] . '" data-action="purchase">';
            $payment_list_html .= '<span class="payment-name"><img class="invoice-loader" src="/assets/img/ajaxloader.gif"> ' . $method['name'] . '</span>';
            $payment_list_html .= $recommended;
            $payment_list_html .= '<div class="payment-icon ' . $method['icon'] . '"></div>';
            $payment_list_html .= '</li>';
        }

        return $this->output->set_content_type('application/json')
            ->set_output(json_encode(array(
                'status' => 'success',
                'payment_methods_html' => $payment_list_html
            )));
    }

    public function buy_crypto()
    {
        $this->load->view('donation/buy_crypto');
    }

    public function bonus($action = '')
    {
        $data = array();
        $data['aborted_download'] = false;
        if ($action == 'payment_accepted') {
            $data['credit_card_message'] = true;
        } else if ($action == 'pending_confirmation') {
            $data['crypto_message'] = true;
        } else if ($action == 'disabled') {
            $data['disabled_message'] = true;
        } else if ($action == 'payment_refused') {
            $data['payment_refused'] = true;
        }
        if (isset($_GET['abort_download'])) {
            $torrent_id = $this->input->get('abort_download', true);
            $torrent = $this->db->where('id', $torrent_id)->get('torrents')->row();

            if (isset($torrent->id)) {
                $futuredownload = $torrent->size + $this->session->downloaded;
                $missingupload = $futuredownload - $this->session->uploaded;

                if ($missingupload > 0) {
                    $data['aborted_download'] = true;
                    $data['aborted_torrent_name'] = $torrent->name;
                    $data['aborted_torrent_size'] = bytesToSize($torrent->size);
                    $data['missing_go'] = bytesToSize($missingupload);
                }
            }
        }

        $this->load->view('donation/bonus_trusted_users', $data);
    }

    public function history()
    {
        $this->load->view('donation/history');
    }

    private function return_error($message)
    {
        return $this->output->set_content_type('application/json')
            ->set_output(json_encode(array(
                'status' => 'error',
                'message' => $message
            )));
    }

    /**
     * Vérifier si un utilisateur a des restrictions de paiement
     * Retourne true si l'utilisateur doit avoir des moyens de paiement limités
     */
    private function check_user_payment_restrictions($user_id)
    {
        // Vérifier si l'utilisateur est déjà en blacklist
        $is_blacklisted = $this->check_user_blacklist($user_id);
        
        if ($is_blacklisted) {
            return true;
        }
        
        // Vérifier le rank de l'utilisateur (administrateur, modérateur, team pending)
        $user_rank = $this->session->userdata('rank');
        $restricted_ranks = [1, 2, 3]; // 1=admin, 2=modérateur, 3=team pending
        
        if (in_array($user_rank, $restricted_ranks)) {
            $rank_names = [
                1 => 'administrateur',
                2 => 'modérateur',
                3 => 'team pending'
            ];
            
            $this->add_user_to_blacklist($user_id, 'restricted_rank', [
                'rank' => $user_rank,
                'rank_name' => $rank_names[$user_rank]
            ]);
            
            return true;
        }
        
        // Si pas en blacklist, vérifier les critères actuels via les données de session/navigateur
        // Note: Dans create_order, nous n'avons pas accès aux données du navigateur
        // donc nous nous basons uniquement sur la blacklist existante
        return false;
    }

    /**
     * Obtenir la liste des moyens de paiement autorisés pour un utilisateur
     */
    private function get_allowed_payment_methods($user_id)
    {
        $has_restrictions = $this->check_user_payment_restrictions($user_id);
        
        if ($has_restrictions) {
            // Moyens de paiement restreints
            return ['crypto', 'onramp', 'onramp2'];
        } else {
            // Tous les moyens de paiement
            return ['paypal', 'revolut', 'mercuryo', 'onramp', 'cc3ds', 'crypto', 'onramp2'];
        }
    }

    /**
     * Vérifier les restrictions avec les données du navigateur (pour get_payment_modal)
     */
    private function check_user_payment_restrictions_with_browser_data($user_id, $timezone, $language, $user_agent, $screen_resolution, $color_depth, $platform)
    {
        // Vérifier si l'utilisateur est déjà en blacklist
        $is_blacklisted = $this->check_user_blacklist($user_id);
        
        if ($is_blacklisted) {
            return true;
        }
        
        // Vérifier le rank de l'utilisateur (administrateur, modérateur, team pending)
        $user_rank = $this->session->userdata('rank');
        $restricted_ranks = [1, 2, 3]; // 1=admin, 2=modérateur, 3=team pending
        
        if (in_array($user_rank, $restricted_ranks)) {
            $rank_names = [
                1 => 'administrateur',
                2 => 'modérateur',
                3 => 'team pending'
            ];
            
            $this->add_user_to_blacklist($user_id, 'restricted_rank', [
                'rank' => $user_rank,
                'rank_name' => $rank_names[$user_rank],
                'timezone' => $timezone,
                'language' => $language,
                'user_agent' => $user_agent,
                'screen_resolution' => $screen_resolution,
                'color_depth' => $color_depth,
                'platform' => $platform
            ]);
            
            return true;
        }
        
        // Si pas encore en blacklist, vérifier les critères actuels
        // Timezones des pays avec moyens de paiement limités: USA, Ireland, Inde, Pakistan, Kuwait
        $restricted_timezones = [
            // USA
            'America/New_York', 'America/Chicago', 'America/Denver', 'America/Los_Angeles',
            'America/Phoenix', 'America/Anchorage', 'Pacific/Honolulu', 'America/Detroit',
            'America/Kentucky/Louisville', 'America/Kentucky/Monticello', 'America/Indiana/Indianapolis',
            'America/Indiana/Vincennes', 'America/Indiana/Winamac', 'America/Indiana/Marengo',
            'America/Indiana/Petersburg', 'America/Indiana/Vevay', 'America/North_Dakota/Center',
            'America/North_Dakota/New_Salem', 'America/North_Dakota/Beulah', 'America/Menominee',
            'America/Metlakatla', 'America/Sitka', 'America/Yakutat', 'America/Nome',
            'America/Adak', 'America/Boise', 'America/Juneau',
            
            // Ireland
            'Europe/Dublin',
            
            // Inde
            'Asia/Kolkata',
            
            // Pakistan
            'Asia/Karachi',
            
            // Kuwait
            'Asia/Kuwait'
            // Hongrie (Europe/Budapest - ajouté pour maintenir la compatibilité)
           // 'Europe/Budapest'
        ];
        
        $has_restrictions = in_array($timezone, $restricted_timezones);
        
        // Si les critères sont remplis, ajouter l'utilisateur à la blacklist
        if ($has_restrictions) {
            $this->add_user_to_blacklist($user_id, 'restricted_timezone', [
                'timezone' => $timezone,
                'language' => $language,
                'user_agent' => $user_agent,
                'screen_resolution' => $screen_resolution,
                'color_depth' => $color_depth,
                'platform' => $platform
            ]);
        }
        
        return $has_restrictions;
    }

    /**
     * Vérifier si un utilisateur est en blacklist
     */
    private function check_user_blacklist($user_id)
    {   
        $query = $this->db->where('user_id', $user_id)->get('payment_blacklist');
        return $query->num_rows() > 0;
    }

    /**
     * Ajouter un utilisateur à la blacklist
     */
    private function add_user_to_blacklist($user_id, $trigger_type, $trigger_data = [])
    {
        // Vérifier si l'utilisateur n'est pas déjà en blacklist
        if (!$this->check_user_blacklist($user_id)) {
            $data = [
                'user_id' => $user_id,
                'trigger_type' => $trigger_type,
                'trigger_data' => json_encode($trigger_data),
                'created_at' => time(),
                'updated_at' => time()
            ];
            
            $this->db->insert('payment_blacklist', $data);
        }
    }
}