<?php

use \Slim\Http\Request as Request;
use \Slim\Http\Response as Response;
use Yadakhov\Json as Json;


// The hookmanager is the web-exposed class that allows you to manage a user within the billing system.
// This system takes care of CRUD operations on customers. It doesn't keep track of order but it does suspend 
// you if you don't pay.

class Hookmanager
{
    
    
    private $Customer;
    
    
    private $Renderview;
    
    
    private $APITools; 
    
    
    private $Mailer;
    
    
    // Can be overloaded by child classes in order to add new features.W
    protected $alertTypes = 
    [
            "subscription_created",
            "subscription_updated",
            "subscription_cancelled",
            "subscription_payment_succeeded",
            "subscription_payment_failed",
            "subscription_payment_refunded",
            "payment_refunded"
            
    ];
    
    
    private $AppBaseURL; 
    
    
    public function __construct()
    {
        
        $this->Customer = new Customer();
        $this->Renderview = new EmailRenderer();
        $this->APITools = new ApplicationAPI();
        $this->JsonHelper = new Json();
        
        // Create mailer when needed
        
        
    }
    
      private function keyValidate($keyFromURI)
     {
        // FIXME: Theoretically, this method does not work.
        // TODO: Devise a new way to validate keys without user ID
        if($this->APITools->keysMatch($keyFromURI))
        {
            return true;
        }
        else
        {
            return false;   
        }
     }
     
    /**
     * 
     *  This function detects the intent within the payload.
     *  After doing so, it returns the intent back to you so that you can perfom the correct redirect
     * 
     */ 
    public function detectPayloadIntent(Request $request, Response $response, $args)
    {
        if ($this->keyValidate($keyFromURI))
        {
            
            $data = $this->getStructuredVariableList($Request);
            
            foreach ($this->alertTypes as $types => $value)
            {
                if ($types == $data['alert_name'])
                {
                    $sVal = $value;
                }
            }
         
            // Uses the response and redirect objects and the intent from the current request to redirect it
            $this->redirectAlert($request, $response, $sVal);
            
            
        }
        
        throw new LogicException("Illegal API key");
        
        
    }
    
    // The response and request method is passed by the redirecting method
    private function redirectAlert(Request $Request, Response $response, $intent)
    {
        
        switch ($intent)
        {
            // This serves as a proxy to all other methods
            case "subscription_created":
                
                $this->EventSubscriptionCreated($Request, $response);
                
                
                break;
                
            case "subscription_updated":
                
                $this->EventSubscriptionUpdated($Request, $response)
                
                break;
                
            case "subscription_cancelled":
            
                $this->EventSubscriptionCancelled($Request, $response);
            
                break;
                
            case "subscription_payment_successful":
                
                $this->EventSubscriptionPaymentSuccess($Request, $response);
                
                break;
                
            case "subscription_payment_failed":
                
                $this->EventSubscriptionPaymentFailed($Request, $response);
                
                break;
                
            case "subscription_payment_refunded":
                
                $this->EventSubscriptionPaymentRefunded($Request, $response);
                
                break;
            
            default:
                
                $this->JsonHelper->set
                                      ([
                                        "status" => "fail",
                                        "message" => "Error: Invalid alert type (Or middleman attack in-progress)",
                                        "code" => 500
                                        
                                      ]);
                // Writing JsonHelper while it's not a string but an object will cause it to fire it's __toString method, which 
                // assembles the JSON defined in the array notation as written above in the form of an array.
                // Calling Slim's withStatus method gives us the ability to tell the client something went wrong.
                return $response->write($this->JsonHelper)->withStatus(500);
             
        }
        
    }
    
    
    // Return POST variable list in a structured array, DRY
    private function getStructuredVariableList(Request $request)
    {
        $PDATA = $request->getParsedBody();
        $dArr = [];
        
        foreach($PDATA as $key => $param)
        {
               $dArr[$key => $param]; // Turn parsed body into an array.
               
        } 
        
        return $dArr;
    }
    
    
    public function EventSubscriptionCreated(Request $request, Response $response, $args)
    {
       
       return $response->write($this->getStructuredVariableList($Request))->withStatus(200);
            
    }
    
    public function EventSubscriptionUpdated(Request $request, Response $response, $args)
    {
        // Update user information if necessary
    }
    
    public function EventSubscriptionCancelled(Request $request, Response $response, $args)
    {
        
        // Suspend user's domain name as stated on DB
        // Delete after 30 days
        
    }
    
    public function EventSubscriptionPaymentSuccess(Request $request, Response $response, $args)
    {
        
        // Renew user's subscription within billing system
        // Install hosting account if this is the user's first time and send out instructions email
        
    }
    // TODO: Lenient business logic
    public function EventSubscriptionPaymentFailed(Request $request, Response $response, $args)
    {
        
        // Add payment strike to user account
        // After three strikes, warn user that the system has waived further attempts. Suspend their account
        // Give user an ultimatum: Pay or remain suspended
        // If user fails to pay during the next 7 days, permanently suspend their account (Reject further payments. Remove user from paddle first)
        // If payment is successful afterwards, remove all payment strikes (Success logic should execute automatically)
        
    }
    
    public function EventSubscriptionPaymentRefunded(Request $request, Response $response, $args)
    {
        // Ban customer from billing system
        // Delete all customer data
    }
    
    
}