from common.common import CostDetail


class AWSProcesser:
    def __init__(self, data, provider, region, date_str):
        self.data = data
        self.region = region
        self.provider = provider
        self.pre_task = [MergeCostByService()]
        self.date = date_str
        self.task = [DealS3Cost(self.provider, self.region, self.date),
                     DealCloudWatchCost(self.provider, self.region, self.date),
                     DealWAFFixedCost(self.provider, self.region, self.date),
                     DealWAFCost(self.provider, self.region, self.date),
                     DealDataTransferCost(
                         self.provider, self.region, self.date),
                     DealECRCost(self.provider, self.region, self.date),
                     DealEBSCost(self.provider, self.region, self.date),
                     DealNatGatewayFixedCost(
                         self.provider, self.region, self.date),
                     DealNatGatewayCost(self.provider, self.region, self.date),
                     DealEC2Cost(self.provider, self.region, self.date),
                     DealEKSCost(self.provider, self.region, self.date),
                     DealELBFixedCost(self.provider, self.region, self.date),
                     DealELBCost(self.provider, self.region, self.date)]

    def process(self):
        pre_result = {}
        for task in self.pre_task:
            pre_result = task.deal(self.data)
        final = []
        for task in self.task:
            cost = task.deal(pre_result)
            final.append(cost)
        return final


class MergeCostByService:
    def deal(self, data):
        # {'Keys': ['AWS Key Management Service','us-east-1-KMS-Keys']} -> {'AWS Key Management Service':{"us-east-1-KMS-Keys":"0.995967726"}}
        result = {}
        if "Groups" in data:
            for group in data["Groups"]:
                if "Keys" in group and "Metrics" in group:
                    keys = group["Keys"]
                    metrics = group["Metrics"]
                    if keys[0] not in result:
                        result[keys[0]] = {
                            keys[1]: metrics["UnblendedCost"]["Amount"]
                        }
                    else:
                        result[keys[0]][keys[1]
                                        ] = metrics["UnblendedCost"]["Amount"]
        return result


# Amazon Simple Storage Service
class DealS3Cost:
    def __init__(self, provider, region, date_str):
        self.service = "Simple Storage Service"
        self.inner_service = "Amazon Simple Storage Service"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal s3 cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                if "Requests-Tier" in key:
                    cost += float(value)
                if "TimedStorage-ByteHrs" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# AmazonCloudWatch


class DealCloudWatchCost:
    def __init__(self, provider, region, date_str):
        self.service = "CloudWatch"
        self.inner_service = "AmazonCloudWatch"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# AWS WAF fixed cost
# e.g. WebACLRule and Rule


class DealWAFFixedCost:
    def __init__(self, provider, region, date_str):
        self.service = "WAF"
        self.inner_service = "AWS WAF"
        self.provider = provider
        self.region = region
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                if "Rule" in key:
                    cost += float(value)
                if "WebACL" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# AWS WAF  cost
# e.g. RequestV2


class DealWAFCost:
    def __init__(self, provider, region, date_str):
        self.service = "WAF"
        self.inner_service = "AWS WAF"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                if "RequestV2" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# Data Transfer  cost
# Data Transfer is a composite cost that is billed as the in/out spend for each service.
class DealDataTransferCost:
    def __init__(self, provider, region, date_str):
        self.service = "Data Transfer"
        self.inner_service = "Data Transfer"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data: dict):
        # we should get all in/out and DataTransfer cost
        cost = float(0)
        for values in data.values():
            for key, value in values.items():
                if "DataTransfer" in key:
                    cost += float(value)
                elif "In-Bytes" in key:
                    cost += float(value)
                elif "Out-Bytes" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# Amazon EC2 Container Registry (ECR)


class DealECRCost:
    def __init__(self, provider, region, date_str):
        self.service = "Container Registry"
        self.inner_service = "Amazon EC2 Container Registry (ECR)"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# EC2 EBS  cost


class DealEBSCost:
    def __init__(self, provider, region, date_str):
        self.service = "EBS"
        self.inner = "EC2 - Other"
        self.inner_service = "EC2 EBS"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner in data:
            for key, value in data[self.inner].items():
                if "EBS:Volume" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# nat
# EC2 NatGateway  fixed cost


class DealNatGatewayFixedCost:
    def __init__(self, provider, region, date_str):
        self.service = "NatGateway"
        self.inner = "EC2 - Other"
        self.inner_service = "EC2 NatGateway"
        self.provider = provider
        self.region = region
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner in data:
            for key, value in data[self.inner].items():
                if "NatGateway-Hours" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# EC2 NatGateway  cost


class DealNatGatewayCost:
    def __init__(self, provider, region, date_str):
        self.service = "NatGateway"
        self.inner = "EC2 - Other"
        self.inner_service = "EC2 NatGateway"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner in data:
            for key, value in data[self.inner].items():
                if "NatGateway-Bytes" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# Amazon Elastic Compute Cloud - Compute


class DealEC2Cost:
    def __init__(self, provider, region, date_str):
        self.service = "Elastic Compute"
        self.inner = "EC2 - Other"
        self.inner_service = "Amazon Elastic Compute Cloud - Compute"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                if "BoxUsage" in key:
                    cost += float(value)
        # merge ec2 other cpu credits to ec2 cost
        if self.inner in data:
            for key, value in data[self.inner].items():
                if "CPUCredits" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)
# eks


class DealEKSCost:
    def __init__(self, provider, region, date_str):
        self.service = "Kubernetes Service"
        self.inner_service = "Amazon Elastic Container Service for Kubernetes"
        self.provider = provider
        self.region = region
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)
# elb


class DealELBFixedCost:
    def __init__(self, provider, region, date_str):
        self.service = "Elastic Load Balancing"
        self.inner_service = "Amazon Elastic Load Balancing"
        self.provider = provider
        self.region = region
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                if "LoadBalancerUsage" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


class DealELBCost:
    def __init__(self, provider, region, date_str):
        self.service = "Elastic Load Balancing"
        self.inner_service = "Amazon Elastic Load Balancing"
        self.provider = provider
        self.region = region
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data):
        # deal cost
        cost = float(0)
        if self.inner_service in data:
            for key, value in data[self.inner_service].items():
                if "LCUUsage" in key:
                    cost += float(value)
        return CostDetail(self.provider, self.region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)