"""
This file is a wrapper for stripe and store handling operations :

@TODO:
    - Add logging using transport
"""
import stripe
from utils.params import PARAMS as SYS_ARGS
from utils import void
import json
class User :
    def __init__(self,email,plans):
        self.plans = plans
        self.me = {"plan":[],"customer":{},"payments":[],"plan2sub":{}}
        self.init(email)
        self.format() #-- creating properties
        pass
    def info(self):
        return self.me['customer']
    def _add_card(self,card):
        try:
            stripe.token.Token.create(customer=self.me["customer"]['id'],card=card)
            self.init(self.me["customer"]['email'])
            return 1
        except Exception as error :
            print (error)
            return 0
    def charge(self,**args) :
        """
        This function will charge a user for a service (given a plan id)
        :plan_id     plan identifier for the current product
        :card_index  provide a token (otherwise will use a valid card)
        """
        plan_id     = args['plan_id']
        if len(self.me["payments"]) == 1 :
            card_index = 0
        else:
            card_index  = args['card_index'] 
        plan = [item[plan_id] for item in self.plans if item['id'] == plan_id]
        
        card = {} if plan['amount'] == 0 else self.me["payments"][card_index]
        params = {}
        
        params['customer']  = self.me["customer"]['id']
        params ['amount']   = plan['amount']
        params ['currency'] = plan['currency']
        params ['description'] = " ".join([self.product['statement_descriptor'],plan['nickname']])
        if 'source' in card :
            params ['source']   = card['source'] 
        
        stripe.charge.Charge.create(params)
        del params['amount'], params['currency']

        stripe.invoice.Invoice.create(**params) 
        pass
    
    def format(self):
        
        self.plan = void()
        self.plan.info =  lambda: self.me["plan"] 
        self.plan.sub_id = lambda: self.me['plan2sub'].get(self.plan.info()['id'],{})
        # self.user.plan.cancel = lambda id: stripe.subscription.Subscription.delete(self.customer['id'],prorate=True,invoice_now=True)

        self.card = void ()
        self.card.exists    = lambda: len(self.me["payments"]) > 0
        self.card.add       = self._add_card
        self.card.charge    = self.charge
        self.card.html      = lambda: [{} for card in self.me["payments"]]
        self.card.delete    = lambda index: stripe.customer.Customer.delete_source(self.me["customer"]['id'],self.me["payment"][index])
    
    def init(self,email):
        #
        # get customer information
        # email = args['email']
        # self.user_plan  = []
        # self.customer   = {}
        customer = stripe.customer.Customer.list(email=email).to_dict_recursive()['data']
        free_plan = [item for item in self.plans if item['amount'] == 0]
        if customer :
            customer = customer[0]
        else:
            #
            # The user doesn't exist, we must create the user (without payment initially)
            # We can probably assign the user to a free plan if available
            #
            customer = stripe.customer.Customer.create(email=email)
            
            # if free_plan :
            #     free_plan = free_plan[0]
            #     self.plan.subscribe(free_plan['id'],email)
        # self.customer = {"email":email,"id":customers['id']}
        self.me["customer"] = {"email":email,"id":customer['id']}
        lsub = customer.subscriptions.data
        for sub in lsub :
            
            id =  sub.plan.id
            self.me['plan2sub'][id] = sub.id
            
        #
        # extract payments available,
        if 'sources' in customer and 'data' in customer['sources'] :
            if customer['sources']['data'] :
                # self.payment = [ card.to_dict_recursive() for card in customers['sources']['data'] ]
                self.me['payments'] = [ card.to_dict_recursive() for card in customer['sources']['data'] ]
        # if not self._has_plan(customer) and free_plan:
        #     free_plan = free_plan[0]
        #     self.subscribe(free_plan['id'],email)
        # info = customers #self.me['customer']
        # subscriptions = info['subscriptions']['data']
        # ids = [plan['id'] for plan in self.plans ]
        # _found = None
        # for sub in subscriptions :
        #     aplan = sub['plan']
            
        #     if set([aplan['id']]) & set(ids):
        #         _found = sub.to_dict_recursive()                       
        #         break
        self.me["plan"] = self._has_plan(customer) #_found if _found else []
        # self.user_plan = _found if _found else None 
    def _has_plan(self,customer):
        subscriptions = customer['subscriptions']['data']
        ids = [plan['id'] for plan in self.plans ]
        _found = None
        for sub in subscriptions :
            aplan = sub['plan']
            
            if set([aplan['id']]) & set(ids):
                _found = sub.to_dict_recursive()['plan']
                if 'features' in _found['metadata'] :
                    _found ['metadata']['features'] = json.loads(_found['metadata']['features'])
                break
        return _found if _found else []
class Store :
    def __init__(self,**args):
        """
        Creating an instance of a store. A store is a proxy to stripe (https://stripe.com)
        :name   name of the product
        :secret stripe api key
        """
        self.products   = []
        self.plans      = []
        self.product    = {}
        
        product_name    = args['name']
        stripe.api_key  = args['secret'] if 'secret' in args else stripe.api_key
        resp = stripe.product.Product.list().to_dict_recursive()['data']
        if resp :
            self.products = [item.to_dict_recursive() for item in resp]
            if len(self.products) > 1 :                
                self.product = [item for item in self.products if item['name'] == product_name]
                self.product = self.product[0] if self.product else []
            else:
                self.product = self.products[0]
        #
        # if we have a product we should get the list of plans associated
        #
    def init(self,email):
        """
        This function pulls a user's information, think of it like a customer walks into a store ...
        :email
        """
        pass
class Product(Store):
    """
    This class implements a wrapper around products, services or just simple donations
    we are inheriting product, plans
    """
    def __init__(self,**args):
        Store.__init__(self,**args)

    def set(self,key,value):
        if key == 'plan' :
            #
            # do we have this plan
            found = [item for item in self.plans if item['id'] == value['id']]
            if not found :
                plan = value
            else:
                plan = dict(found[0],**value)
            if 'metadata' in value :
                plan['metadata'] = self.meta(plan,value)
                self.save('plan',plan)
            
            pass
        else :
            if key in ['type','name','id','statement_descriptor'] :
                if value :
                    self.product[key] = value
                elif key in self.product :
                    del self.product[key]
            elif key == 'metadata' :
                self.product['metadata'] = self.meta(self.product,value)
            self.save('product',self.product)

        
    def meta(self,object,value) :
        
        for k in value :
            if value[k] :
                object['metadata'][k] = json.dumps(value[k]) if type(value[k]) == dict else value[k]
            else:
                del object['metadata'][k]
        return object

    def save(self,id,object):
        pointer = None
        if id == 'product' :
            p = 'about' in object['metadata']
            q =  'uri'  in object['metadata']
            if p and q :
                pointer = stripe.product.Product
                return 1
            else :
                return 0
        elif self.product['id']:
            pointer = stripe.plan.Plan
            object = dict(object,**{"product":{"name":self.product['id']}} )
        if pointer :
            pointer.create(**object)
            return 1
        return 0

    def get(self):
        pass
class Plans(Store) :
    def __init__(self,**args):
        """
        This function will retrieve plan information associated with the given product id
        """
        Store.__init__(self,**args)
        self.plans = stripe.plan.Plan.list(product=self.product['id']).to_dict_recursive()['data']
        for item in self.plans :
            index = self.plans.index(item)
            self.plans[index] = item.to_dict_recursive()
            if 'features' in self.plans[index]['metadata'] :
                self.plans[index]['metadata']['features'] = json.loads(self.plans[index]['metadata']['features'])
        self.plans.sort(key=lambda item: item['amount'])
        if 'email' in args :
            self.user = User(args['email'],self.plans)
        else:
            self.user = None
        # self.plans = [item.to_dict_recursive() for item in self.plans]
        self.format()
    def format(self):
        self.get = void()
        self.get.plans = lambda:self.plans
        self.get.products = lambda:self.products
        self.plan = void()
        self.plan.upgrade   = self.upgrade
        self.plan.cancel    = self.cancel        
        self.plan.subscribe = self.subscribe
    def cancel(self,id) :
        """
        This function will cancel a subscription given a user's email/or a subscription for the given product/user
        We are assuming one subscription one plan, no complex billing is involved (not good for startups)
        :email,subscription
        """
        stripe.subscription.Subscription.delete(id,prorate=True,invoice_now=True)
        pass
    def upgrade(self,id,email):
        """
        A change of plan suggests cancelling the current plan and assigning a new one.
        If it's a paid plan, the calling code must insure the user has an active token
        """
        if not self.user and email:
            self.user  = User(email,self.plans)

        # sub_id = self.user.plan.info()['id']
        sub_id = self.user.plan.sub_id()
        try:
            self.cancel(sub_id)
            r = self.subscribe(id=id,email=email)
            #
            # We need to reload everything
            self.user.init(email)
        except Exception as error :
            print (error) ;
            return 0
        return 1

        pass
    # def subscribe(self,id,email):
    def subscribe(self,**args):
        """
        Subscribe a user to a given plan assuming the user has already been initialized
        The responsibility falls upon the calling code to perform the cancellatioin of the existing plan and perform an upgrade
        :email  user's email
        :id     plan id (optional) will default to free plan
        """
        free_plan = [item['id'] for item in self.plans if item['amount'] == 0]
        if free_plan :
            free_plan = free_plan[0]
        # id = args['id'] if 'id' in args else free_plan
        email = args['email']
        if not self.user :
            self.user = User(email,self.plans)
        
        
        plan = {"plan": args['id'] if 'id' in args else free_plan}
        amount = sum([item['amount'] for item in self.plans if item['id'] == 0])

        if 'email' in self.user.info() and email == self.user.info()['email'] :
            email  = self.user.info()['email']
        else:
            self.user.init(email)
        #
        # We must insure the user is one of our customers i.e perhaps
        if amount == 0 or self.payment :
            r = stripe.subscription.Subscription.create(
                customer = self.user.info()['id'],
                items = [plan]
            )
            # stripe.subscription.Subscription.create(
            #     customer=self.user.info()['id'], #if not email else email,
            #     items=[plan]
            # )

            self.user.init(email)
            return 1
        else:
            return 0
class factory:
    @staticmethod
    def instance (**args) :
        p =  Plans(**args)
        # p.user.subscribe = p.subscribe
        return p
            
        # if 'email' in args :
        #    store = Plans(**args)
            
        # else:
        #     store = Plans(**args)
        # return store
# class _Store :
#     # stripe_keys = {
#     #     "secret_key":SYS_ARGS['stripe']['secret'].strip(),
#     #     "publishable_key":SYS_ARGS['stripe']['pub'].strip()
#     # }
#     # stripe.api_key = self.stripe_keys['secret_key']

#     def __init__(saelf,**args):
#         self.payment    = []
#         self.user_plan  = {}
#         self.customer   = {}

#         self.get = void()
#         # self.get.user   = void()
#         # self.get.user.info = self._get_user
#         # self.get.user.plan = lambda: self.user_plan if self.user_plan else None 
        

#         # self.add = void()
#         # self.add.user = self.init
#         # self.add.card = lambda card: stripe.token.Token.create(customer=customer['id'],card=card)
        
#         self.user  = void()
#         self.user.init = self.init
#         self.user.info = self._get_user
#         self.user.plan = void()
#         self.user.plan.info =  lambda: self.user_plan if self.user_plan else None 
#         # self.user.plan.cancel = lambda id: stripe.subscription.Subscription.delete(self.customer['id'],prorate=True,invoice_now=True)

#         self.user.card = void ()
#         self.user.card.exists = lambda: len(self.payment) > 0
#         self.user.card.add = self._add_card
#         self.user.card.charge   = self._apply_charge
#         self.user.card.html     = lambda: [{} for card in self.payment]
#         self.user.card.delete   = lambda index: stripe.customer.Customer.delete_source(self.customer['id'],self.payment[index])

#         self.get.plans  = self._get_plans
        

#         self.has = void ()
        
#         product_name    = args['product']
#         stripe.api_key = args['secret'] if 'secret' in args else stripe.api_key
#         if stripe.api_key :                    
#             self.__init_product(product_name)
#         else:
#             print (['secret' in args, stripe.api_key is None])
#         self.plan = void()
#         self.plan.cancel    = self.__cancel_plan 
#         self.plan.subscribe = self.__subscribe_plan
#         self.plan.upgrade   = self.__upgrade_plan
#     def _apply_charge(self,**args) :
#         """
#         This function will charge a user for a service (given a plan id)
#         :plan_id     plan identifier for the current product
#         :card_index  provide a token (otherwise will use a valid card)
#         """
#         plan_id     = args['plan_id']
#         if len(self.payment) == 1 :
#             card_index = 0
#         else:
#             card_index  = args['card_index'] 
#         plan = [item[plan_id] for item in self.plans if item['id'] == plan_id]
        
#         card = {} if plan['amount'] == 0 else self.payment[card_index]
#         params = {}
        
#         params['customer']  = self.customer['id']
#         params ['amount']   = plan['amount']
#         params ['currency'] = plan['currency']
#         params ['description'] = " ".join([self.product['statement_descriptor'],plan['nickname']])
#         if 'source' in card :
#             params ['source']   = card['source'] 
        
#         stripe.charge.Charge.create(params)
#         del params['amount'], params['currency']

#         stripe.invoice.Invoice.create(**params        ) 
#         pass
#     def __init_product(self,product_name):
#         PRODUCT_INDEX   = 2
#         DATA_TYPE_INDEX = 1
#         STATUS_INDEX    = 0
#         resp = stripe.product.Product.list().to_dict_recursive()['data']
#         self.product    = []
#         self.plan       = []
#         if resp :
            
#             if resp :                
#                 self.product = [p.to_dict_recursive() for p in resp if p['name'] == product_name]
#                 self.product = self.product[0] if self.product else []
#             else:
#                 self.product = resp[0]
            
#             if 'id' in self.product :
#                 self.__init_plan(self.product['id'])
                
#     def __init_plan(self,id):
#         """
#         This function will retrieve plan information associated with the given product id
#         """
#         self.plans = stripe.plan.Plan.list(product=id).to_dict_recursive()['data']
#         for item in self.plans :
#             index = self.plans.index(item)
#             self.plans[index] = item.to_dict_recursive()
#             if 'features' in self.plans[index]['metadata'] :
#                 self.plans[index]['metadata']['features'] = json.loads(self.plans[index]['metadata']['features'])
#         #
#         # sort items by amounts
#         #
#         self.plans.sort(key=lambda item: item['amount'])
#         # self.plans = [item.to_dict_recursive() for item in self.plans]
        
#     def init(self,email):
#         #
#         # get customer information
#         # email = args['email']
#         self.user_plan  = []
#         self.customer   = {}
#         customers = stripe.customer.Customer.list(email=email).to_dict_recursive()['data']
#         if customers :
#             customers = customers[0]
#         else:
#             #
#             # The user doesn't exist, we must create the user (without payment initially)
#             # We can probably assign the user to a free plan if available
#             #
#             customers = stripe.customer.Customer.Create(email=email)
#             free_plan = [item for item in self.plans if item['amount'] == 0]
#             if free_plan :
#                 free_plan = free_plan[0]
#                 self.plan.subscribe(free_plan['id'],email)
#         self.customer = {"email":email,"id":customers['id']}
#         #
#         # extract payments available,
#         if 'sources' in customers and 'data' in customers['sources'] :
#             if customers['sources']['data'] :
#                 self.payment = [ card.to_dict_recursive() for card in customers['sources']['data'] ]
#         #
#         # user plans 
#         info = customers
#         subscriptions = info['subscriptions']['data']
#         ids = [plan['id'] for plan in self.plans ]
#         _found = None
#         for sub in subscriptions :
#             aplan = sub['plan']
            
#             if set([aplan['id']]) & set(ids):
#                 _found = sub.to_dict_recursive()                       
#                 break

#         self.user_plan = _found if _found else None        
#     def _get_user(self,**args):
#         """
#         This function will return a customer information and associated plan (hopefully)
#         :email
#         """
#         return self.customer
        
#     def __cancel_plan(self,id) :
#         """
#         This function will cancel a subscription given a user's email/or a subscription for the given product/user
#         We are assuming one subscription one plan, no complex billing is involved (not good for startups)
#         :email,subscription
#         """
#         stripe.subscription.Subscription.delete(id,prorate=True,invoice_now=True)
#         pass
#     def __upgrade_plan(self,id,email=None):
#         """
#         A change of plan suggests cancelling the current plan and assigning a new one.
#         If it's a paid plan, the calling code must insure the user has an active token
#         """
#         email = self.customer['email'] if email is None else email
#         sub_id = self.user.plan.info()['id']
#         try:
#             self.plan.cancel(sub_id)
#             self.plan.subscribe(id,email)
#             #
#             # We need to reload everything
#             self.user.init(email)
#         except Exception as error :
#             print (error) ;
#             return 0
#         return 1

#         pass
#     def __subscribe_plan(self,id,email):
#         """
#         Subscribe a user to a given plan assuming the user has already been initialized
#         The responsibility falls upon the calling code to perform the cancellatioin of the existing plan and perform an upgrade
#         """
        
#         plan = {"plan": id}
#         amount = sum([item['amount'] for item in self.plans if item['id'] == 0])

#         if 'email' in self.customer and email == self.customer['email'] :
#             email  = self.customer['email']
#         else:
#             self.init(email)
#         #
#         # We must insure the user is one of our customers i.e perhaps
#         if amount == 0 or self.payment :
#             stripe.subscription.Subscription.create(
#                 customer=self.customer['id'], #if not email else email,
#                 items=[plan]
#             )
#             return 1
#         else:
#             return 0
            
        
#     def _add_card(self,card):
#         try:
#             stripe.token.Token.create(customer=customer['id'],card=card)
#             self.user.init(self.customer['email'])
#             return 1
#         except Exception as error :
#             print (error)
#             return 0
            
#     def _get_plans(self,**args) :
#         """
#         This function will provide an plan for a given user given an email or the list of plans        
#         :email  user email
#         """
#         return self.user_plan if 'email' in args else self.plans