def create_electric_demand_curve(self, aggregate_air_demand):
     curve = PolyLine()
     for point in aggregate_air_demand.points:
         curve.add(Point(price=point.y, quantity=self.calcTotalLoad(point.x)))
     self.buyBidCurve = curve
     _log.debug("Report aggregated curve : {}".format(curve.points))
     return curve

def create_demand_curve():
    demand_curve = PolyLine()
    price = 0
    quantity = 1000
    demand_curve.add(Point(price,quantity))
    price = 1000
    quantity = 0
    demand_curve.add(Point(price,quantity))
    return demand_curve

 def create_supply_curve(self):
     supply_curve = PolyLine()
     price = self.price
     quantity = self.infinity
     supply_curve.add(Point(price=price, quantity=quantity))
     price = self.price
     quantity = 0
     supply_curve.add(Point(price=price, quantity=quantity))
     return supply_curve

def create_supply_curve():
    supply_curve = PolyLine()
    price = 0
    quantity = 0
    supply_curve.add(Point(price,quantity))
    price = 1000
    quantity = 1000
    supply_curve.add(Point(price,quantity))
    return supply_curve

 def create_air_supply_curve(self, electric_price, electric_quantity):
     supply_curve = PolyLine()
     price = 65
     quantity = 100000
     supply_curve.add(Point(price=price,quantity=quantity))
     price = 65
     quantity = 0 # negative quantities are not real -1*10000
     supply_curve.add(Point(price=price,quantity=quantity))
     return supply_curve

    def create_demand_curve(self):
        self.demand_curve = PolyLine()
        pMin = 10
        pMax = 100

        if (self.hvacAvail > 0):
            self.demand_curve.add(Point(price=min(pMin, pMax),quantity=max(self.qMin, self.qMax)*self.Pabsnom))
            self.demand_curve.add(Point(price=max(pMin, pMax),quantity=min(self.qMin, self.qMax)*self.Pabsnom))
        else:
            self.demand_curve.add(Point(price=max(pMin, pMax), quantity=0))
            self.demand_curve.add(Point(price=min(pMin, pMax),quantity=0))
        return self.demand_curve

    def settle(self):
        enough_buys = len(self._buy_offers) > 0
        enough_sells = len(self._sell_offers) > 0
        if enough_buys:
            demand_curve = self._aggregate(self._buy_offers)
        else:
            _log.debug("There are no buy offers.")
        if enough_sells:
            supply_curve = self._aggregate(self._sell_offers)
        else:
            _log.debug("There are no sell offers.")

        if enough_buys and enough_sells:
            intersection = PolyLine.intersection(demand_curve, supply_curve)
        else:
            intersection = None, None, {}

        quantity = intersection[0]
        price = intersection[1]
        aux = PolyLine.compare(demand_curve, supply_curve)

        return quantity, price, aux

def test_poly_line_sum_first_none():
    sum = PolyLine.sum(None,2)
    assert sum == 2

def test_poly_line_max_second_none():
    max = PolyLine.max(1,None)
    assert max == 1

def test_poly_line_sum():
    sum = PolyLine.sum(1,2)
    assert sum == 3

def test_poly_line_max():
    max = PolyLine.max(1,2)
    assert max == 2

def test_poly_line_max_first_none():
    max = PolyLine.max(None,2)
    assert max == 2

 def fromTupples(points):
     polyLine = PolyLine()
     for p in points:
         if p is not None and len(p) == 2:
             polyLine.add(Point(p[0], p[1]))
     return polyLine

def test_poly_line_min_second_none():
    min = PolyLine.min(1,None)
    assert min == 1

def test_poly_line_sum_second_none():
    sum = PolyLine.sum(1,None)
    assert sum == 1

def test_poly_line_add_two_points():
    line = PolyLine()
    line.add(Point(4,8))
    line.add(Point(2,4))
    assert len(line.points) == 2

class LightAgent(MarketAgent, FirstOrderZone):
    """
    The SampleElectricMeterAgent serves as a sample of an electric meter that
    sells electricity for a single building at a fixed price.
    """
    def __init__(self, market_name,agent_name,k,qmax,Pabsnom,nonResponsive,verbose_logging,subscribing_topic, **kwargs):
        super(LightAgent, self).__init__(verbose_logging, **kwargs)
        self.market_name = market_name
        self.agent_name = agent_name        
        self.k = k
        self.qmax = qmax
        self.Pabsnom=Pabsnom        
        self.nonResponsive = nonResponsive
        self.iniState()
        self.subscribing_topic=subscribing_topic
        self.join_market(self.market_name, BUYER, None, self.offer_callback, None, self.price_callback, self.error_callback)

    @Core.receiver('onstart')
    def setup(self, sender, **kwargs):
        _log.debug('Subscribing to '+'devices/CAMPUS/BUILDING1/AHU1/all')
        self.vip.pubsub.subscribe(peer='pubsub',
                                  prefix='devices/CAMPUS/BUILDING1/AHU1/all',
                                  callback=self.updateState)

    def offer_callback(self, timestamp, market_name, buyer_seller):
        result,message=self.make_offer(market_name, buyer_seller, self.create_demand_curve())
        _log.debug("results of the make offer {}".format(result))
        if not result:
            _log.debug("the new lightingt (maintain{}".format(self.qMax))
            gevent.sleep(random.random())
            self.vip.rpc.call('platform.actuator','set_point', self.agent_name,self.subscribing_topic+'/'+self.agent_name,round(self.qNorm,2)).get(timeout=6)

    def create_demand_curve(self):
        self.demand_curve = PolyLine()
        pMin = 10
        pMax = 100

        if (self.hvacAvail > 0):
            self.demand_curve.add(Point(price=min(pMin, pMax),quantity=max(self.qMin, self.qMax)*self.Pabsnom))
            self.demand_curve.add(Point(price=max(pMin, pMax),quantity=min(self.qMin, self.qMax)*self.Pabsnom))
        else:
            self.demand_curve.add(Point(price=max(pMin, pMax), quantity=0))
            self.demand_curve.add(Point(price=min(pMin, pMax),quantity=0))
        return self.demand_curve

    def iniState(self):
        self.hvacAvail = 1
        self.pClear = None
        self.qMin = 0.7
        self.qMax = self.qmax
        self.qNorm=self.qMax
        self.qClear=self.qNorm
 

    def updateState(self, peer, sender, bus, topic, headers, message):
        '''Subscribe to device data from message bus
        '''
        _log.debug('Received one new dataset')
        info = {}
        for key, value in message[0].items():
                  info[key] = value
        self.hvacAvail = info['SupplyFanStatus']
        if (self.hvacAvail > 0):
              self.qNorm=self.qMax  
        else:
              self.qNorm=0


    def updateSet(self):
        if self.pClear is not None and not self.nonResponsive and self.hvacAvail:
            self.qClear = self.clamp(self.demand_curve.x(self.pClear), self.qMax, self.qMin)
        else:
            self.qClear = 0
#        if self.qClear is None:
#            self.qClear = 0.

    def clamp(self, value, x1, x2):
        minValue = min(x1, x2)
        maxValue = max(x1, x2)
        return min(max(value, minValue), maxValue)        
                        
    def price_callback(self, timestamp, market_name, buyer_seller, price, quantity):
        _log.debug("the price is {}".format(price))
        self.pClear=price
        if self.pClear is not None: 
            self.updateSet()
            _log.debug("the new lightingt is {}".format(self.qClear))
            gevent.sleep(random.random())
            self.vip.rpc.call('platform.actuator','set_point', self.agent_name,self.subscribing_topic+'/'+self.agent_name,round(self.qClear,2)).get(timeout=5)


    def error_callback(self, timestamp, market_name, buyer_seller,  error_code, error_message, aux):
        _log.debug("the new lightingt is {}".format(self.qNorm))
        self.vip.rpc.call('platform.actuator','set_point', self.agent_name,self.subscribing_topic+'/'+self.agent_name,round(self.qNorm,2)).get(timeout=5)
        

    def ease(self, target, current, limit):
        return current - np.sign(current-target)*min(abs(current-target), abs(limit))        

def test_poly_line_no_intersection():
    demand1 = create_demand_curve()
    demand2 = create_demand_curve()
    intersection = PolyLine.intersection(demand1, demand2)
    assert len(intersection) == 2

def test_poly_line_intersection_yeilds_two():
    demand = create_demand_curve()
    supply = create_supply_curve()
    intersection = PolyLine.intersection(demand, supply)
    assert len(intersection) == 2

def test_poly_line_intersection_not_none():
    demand = create_demand_curve()
    supply = create_supply_curve()
    intersection = PolyLine.intersection(demand, supply)
    assert intersection is not None