package heca;

import java.sql.Time;

public class Appliance{
      String applianceCategory; //e.g Electricity
      ApplianceType applianceType; //e.g StrictAppliance like Refrigerator
      String applianceName; //e.g WashingMachine
      int usageTime;
      Time scheduledTime;

    public Appliance(String applianceCategory, ApplianceType applianceType, String applianceName, int usageTime,Time scheduledTime) {
        this.applianceCategory = applianceCategory;
        this.applianceType = applianceType;
        this.applianceName = applianceName;
        this.usageTime = usageTime;
        this.scheduledTime = scheduledTime;
    }


}

package heca;

public class Attribute{
    String attibuteName; //e.g WindPower
    double perUnitWeight;
    int consumed;
    int   limit;

        public static class Builder {
            //required
            private  String attibuteName;
            //optional
            private double perUnitWeight;
            private  int consumed;
            private  int   limit;

            public Builder(String size) {
              this.attibuteName = size;
            }

            public Builder perUnitWeight(double value) {
                perUnitWeight = value;
              return this;
            }

            public Builder consumed(int value) {
                consumed = value;
              return this;
            }

            public Builder limit(int value) {
                limit = value;
              return this;
            }

            public Attribute build() {
              return new Attribute(this);
            }
        }

    private Attribute(Builder builder) {
        attibuteName = builder.attibuteName;
        perUnitWeight = builder.perUnitWeight;
        consumed = builder.consumed;
        limit = builder.limit;
    }

    public Attribute(String a){
        this(a, 0.0, 0, (int)1e6);

    }
    public Attribute(String a, double   w, int   m, int l){
        attibuteName = a;
        perUnitWeight = w;
        consumed  = m;
        limit = l;

    }
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("ntattibute : "+this.attibuteName+"tConsumed :"+ this.consumed + "tLimit : "+ this.limit);
        return sb.toString();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((attibuteName == null) ? 0 : attibuteName.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Attribute other = (Attribute) obj;
        if (attibuteName == null) {
            if (other.attibuteName != null)
                return false;
        } else if (!attibuteName.equals(other.attibuteName))
            return false;
        return true;
    }
}

package heca;

import java.sql.Time;
import java.util.List;
import java.util.Map;

public interface Controller {
    public String createUser(String userName);
    public boolean addAppliance(String userId,String applianceCategory);
    public boolean addAppliance(String userId, String applianceCategory,List<Attribute> attribs);
    public void addAttribute(String userId,String applianceCategory,String attributeName);
    public void updateConsumption(String userId,String applianceCategory,String attributeName,int updatedValue);
    public List<Attribute> getMAXExpenses(String userId);
    public List<Attribute> getMINExpenses(String userId);
    public Map<String,List<Attribute>> getAllConsumptionDetails(String userId);
    public List<Attribute> getSpecificConsumptionDetails(String userId,String applianceCategory);
    public Score getScore();
    public Badge getBadge();
    public List<Attribute> getSuggestedOptimizedGoal(String userId,String applianceCategory,int target);
    public boolean modifyGoal(String userId,String applianceCategory,String attributeName,int targetValue);
    public boolean scheduleFlexibleAppliance(String userId,String applianceCategory, Appliance applianceName,Time schedule);

}

package heca;

import java.util.Comparator;

public class CostComparator implements Comparator<Attribute>{

    // fractional knapsack comparator having only Weight(weight per unit) but all items are unbounded..same Value...Hence value ignored
    @Override
    public int compare(Attribute o1, Attribute o2) {
        return ((o1.limit -o1.consumed)*(int)o1.perUnitWeight )      -  ((o2.limit -o2.consumed)*(int)o2.perUnitWeight ) > 0 ? 1:0  ;
    }

}

package heca;

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;

public class EnergyTracker{

    ConcurrentHashMap<String,List<Attribute>> appliances = new ConcurrentHashMap<>();   //AdjacencyMatrix
    Queue<Attribute> maxExpenseHeap = new PriorityQueue<>(20, new CostComparator());
    Queue<Attribute> minExpenseHeap = new PriorityQueue<>(20, new CostComparator().reversed());

    public List<Attribute> getApplianceDetails(String aplianceName){
        if(appliances.containsKey(aplianceName))return appliances.get(aplianceName);
        else return new ArrayList<>();
    }
    public void setApplianceDetails(String aplianceName,List<Attribute> attribs){
        List<Attribute> renewedAttribs = appliances.get(aplianceName);
            if(renewedAttribs==null || renewedAttribs.isEmpty())
                renewedAttribs = attribs;
            else if(appliances.containsKey(aplianceName)){
                renewedAttribs.addAll(attribs);
            }
            appliances.put(aplianceName,renewedAttribs);
            renewedAttribs.forEach((attrib )-> this.maxExpenseHeap.offer(attrib));
            renewedAttribs.forEach((attrib )-> this.minExpenseHeap.offer(attrib));

    }

    public ConcurrentHashMap<String,List<Attribute>> getALLApplianceDetails() {
        return appliances;
    }

    public List<Attribute> get_TopK_MINConsumptionAppliance(int K){
        ArrayList<Attribute> top5minConsumption = new ArrayList<>(K);
        Attribute temp =null;
        for( int i =0; i<K && K< minExpenseHeap.size() && i < minExpenseHeap.size(); ){
            temp = minExpenseHeap.poll();
            top5minConsumption.add(temp);
            minExpenseHeap.offer(temp);
            i++;
        }
        return top5minConsumption;
    }

    public List<Attribute> get_TopK_MAXConsumptionAppliance(int K){
        ArrayList<Attribute> top5minConsumption = new ArrayList<>(K);
        Attribute temp =null;
        for( int i =0; i<K && K< maxExpenseHeap.size() && i < maxExpenseHeap.size(); ){
            temp = maxExpenseHeap.poll();
            top5minConsumption.add(temp);
            maxExpenseHeap.offer(temp);
        }
        return top5minConsumption;
    }
}

package heca;

public class HomeUser{

    String userId;

    EnergyTracker targetExpenseTracker  = new EnergyTracker();
    EnergyTracker actualExpenseTracker  = new EnergyTracker();

    int targetExpenseGoal, monthlyBudget, tillNowExpense;

    public HomeUser(String uID){
        userId = uID;
    }

    /* <TODO> calculate based on :
                            getSavings()
                            getGoalAchieved()
    */
    public Badge showBadgesAndIncentives(){
        return Badge.SILVER;
    }
    /* <TODO> judge based on
                           total consumption cost of all Appliances -> Attribute -> consumed*perUnitWeight
    */
    public Score getScore(){
        return Score.CONSUMES_MEDIUM;
    }


    private int getGoalAchieved(){
        return targetExpenseGoal;
    }
    private int getSavings(){
        return monthlyBudget - tillNowExpense;
    }



    //setters

    public void setTargetExpenseGoal(int targetExpenseGoal) {
        this.targetExpenseGoal = targetExpenseGoal;
    }

    public void setMonthlyBudget(int monthlyBudget) {
        this.monthlyBudget = monthlyBudget;
    }

    public void setTillNowExpense(int tillNowExpense) {
        this.tillNowExpense = tillNowExpense;
    }

}

package heca;

import java.util.HashMap;

public class UserDB{
    HashMap<String,HomeUser> usserMap = new HashMap<>();

    public void addUser(String userId,HomeUser u){
        usserMap.put(userId, u);
    }

    public HomeUser getUser(String userId){
        return usserMap.get(userId);
    }
}

package heca;


import java.sql.Time;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;



public class DesignHECA implements Controller {

    private UserDB userDB = new UserDB();

    @Override
    public String createUser(String userName) {
        String userId = userName+ new java.util.Random();
        HomeUser u = new HomeUser(userId);
        userDB.addUser(userId,u);
        return userId ;
    }

    public HomeUser getUser(String userId) {
        return userDB.getUser(userId);
    }


    /*----------------------- addAppliance ----------------------------------------*/
        @Override
        public boolean addAppliance(String userId, String applianceCategory) {
            if(applianceCategory == null || applianceCategory.isEmpty()) return false;
            else getUser(userId).actualExpenseTracker.setApplianceDetails(applianceCategory,new ArrayList<>()); //telescoping
            return true;

        }
        @Override
        public boolean addAppliance(String userId, String applianceCategory,final List<Attribute> attribs){     // not to be leaked to Client

            HomeUser user  = getUser(userId);

            if(applianceCategory == null || applianceCategory.isEmpty()) return false;
            else
                if(!user.actualExpenseTracker.appliances.containsKey(applianceCategory)){
                    user.actualExpenseTracker.setApplianceDetails(applianceCategory,attribs);  //defensive copy
                }else{
                    List<Attribute> prev = user.actualExpenseTracker.appliances.getOrDefault(applianceCategory, new ArrayList<>());
                    prev.addAll(attribs); //handling override left for brevity
                    user.actualExpenseTracker.setApplianceDetails(applianceCategory,prev);
                }
            return true;
        }


    /*----------------------- addAttribute ----------------------------------------*/
    @Override
    public void addAttribute(String userId, String applianceCategory, String attributeName) {
        List<Attribute> attribs = new ArrayList<>();
        Attribute attribute = new Attribute(attributeName);
        attribs.add(attribute);

        addAppliance(userId, applianceCategory,attribs);

    }

    /*----------------------- updateConsumption ----------------------------------------*/
    @Override
    public void updateConsumption(String userId, String applianceCategory, String attributeName, int tillNowConsumed) {
        //left intentionally for brevity
    }

    /*----------------------- getMAXExpenses ----------------------------------------*/
    @Override
    public List<Attribute> getMAXExpenses(String userId) {
        HomeUser user  = getUser(userId);
        return user.actualExpenseTracker.get_TopK_MAXConsumptionAppliance(10);
    }

    /*----------------------- getMINExpenses ----------------------------------------*/
    @Override
    public List<Attribute> getMINExpenses(String userId) {
        HomeUser user  = getUser(userId);
        return user.actualExpenseTracker.get_TopK_MINConsumptionAppliance(10);
    }
    /*----------------------- getAllConsumptionDetails ----------------------------------------*/
    @Override
    public Map<String, List<Attribute>> getAllConsumptionDetails(String userId) {
        HomeUser user  = getUser(userId);
        return user.actualExpenseTracker.getALLApplianceDetails();
    }


    /*----------------------- getSpecificConsumptionDetails ----------------------------------------*/
    @Override
    public List<Attribute> getSpecificConsumptionDetails(String userId, String applianceCategory) {
        HomeUser user  = getUser(userId);
        //checks omitted for brevity
        return user.actualExpenseTracker.getApplianceDetails(applianceCategory);

    }

    /*----------------------- modifyGoal - lets user to newly calibrate his target expenses ---*/
    @Override
    public boolean modifyGoal(String userId, String applianceCategory, String attributeName, int newlimit) {
        HomeUser user  = getUser(userId);
        List<Attribute> attribs = user.targetExpenseTracker.getApplianceDetails(applianceCategory);
        Attribute temp =null;
        for(int i=0; i<attribs.size();i++){
            if(attributeName.equals(attribs.get(i).attibuteName)){
                temp =attribs.remove(i);
                temp.limit = newlimit;
                attribs.add(temp);
                user.targetExpenseTracker.setApplianceDetails(applianceCategory,attribs);
                return true;
            }
        }
        return false;
    }

    /*---------------------- getSuggestedOptimizedGoals ------------------------------
     * This method Suggests optimized path(Top 5 MIN Expense) for Goal if calibration set by User predicted to meet target
     *  */
    @Override
    public List<Attribute> getSuggestedOptimizedGoal(String userId,String applianceCategory,int target) {
        HomeUser user  = getUser(userId);
        List<Attribute>  attribs = user.actualExpenseTracker.getApplianceDetails(applianceCategory);
        /* e.g
             "PowerSupply",340,880
             "WindPower",120,1
             "SolarEnergy",10,2

        int[] w ={880,1,2};
        int[] c ={340,120,10};

        if( this.canProduce(c,w,user.monthlyBudget -user.tillNowExpense) > 0){ //optimiseed combination
            return this.getMINExpenses(userId);
        }
        else
            return new ArrayList<>();
        */
        return this.getMINExpenses(userId);
    }
    public int canProduce(int[] c,int[] w, int W){
        return min_cost(c.length,W,c,w);
    }

    // Dynamic programming to compute Minimum Cost Path for fixed Weight
    public int min_cost(int N, int W,int[] c, int[] w){
        // min_cost(i, W) = min(min_cost(i+1, W), min_cost(i, W - w[i]) + c[i])

        int[][] dp = new int[N][W];
        int i=0;

            //base cases
               if(dp[i][0] ==  0 ) return 1;       // We already reached our goal
               if(W < 0 || i > N) dp[i][W]  = Integer.MIN_VALUE;  // if (W < 0 or i > N) then we can't get to W

            dp[i][ W] = Math.min(min_cost(i+1, W,c,w), min_cost(i, W - w[i],c,w) + c[i]);

        if(dp[N][ W] <= W)
            return dp[N][ W];
        else
            return 0;//impossible --need to re calibrate
    }


    @Override
    public boolean scheduleFlexibleAppliance(String userId,String applianceCategory, Appliance applianceName,Time schedule) {
        // TODO omitted for brevity
        return false;
    }

    @Override
    public Score getScore() {
        // TODO omitted for brevity
        return null;
    }

    @Override
    public Badge getBadge() {
        // TODO omitted for brevity
        return null;
    }

            /*------------Driver Program -----------------------------------------------------------*/
            public static void main(String args[] ) throws Exception {

                    DesignHECA d = new DesignHECA();
                    String userId = d.createUser("Chandra");

             /** Create Attribute */
                    List<Attribute> attributeList1 = new ArrayList<>();
                        attributeList1.add( new Attribute.Builder("CarOil").perUnitWeight(80.0).consumed(20).limit(60).build());
                        attributeList1.add( new Attribute.Builder("CookingOil").perUnitWeight(60.0).consumed(4).limit(12).build());
                        attributeList1.add( new Attribute.Builder("CandleOil").perUnitWeight(12.0).consumed(2).limit(10).build());
                    List<Attribute> attributeList2 = new ArrayList<>();
                        attributeList2.add( new Attribute.Builder("CrudeOil").perUnitWeight(12.0).consumed(10).limit(80).build());

                    List<Attribute> attributeList3 = new ArrayList<>();
                        attributeList3.add( new Attribute("PowerSupply",340.0,880,60));
                        attributeList3.add( new Attribute("WindPower",120.0,1,2));
                    List<Attribute> attributeList4 = new ArrayList<>();
                        attributeList4.add( new Attribute("SolarEnergy",0.0,0,2));

             /** Create ApplapplianceCategorydd Attributes */
                        d.addAppliance(userId,"Fuel",attributeList1);
                        d.addAppliance(userId,"Fuel",attributeList2);
                        d.addAppliance(userId,"Electricity",attributeList3);
                        d.addAppliance(userId,"Electricity",attributeList4);

             /** Optimize Electric Consumption */

                        /*------------show Electric consumption ----------------------------------------------------------------*/
                                                d.getAllConsumptionDetails(userId).forEach((k,v)-> System.out.println(k+" : "+v));

                        /*------------show Suggested Paths ----------------------------------------------------------------------*/
                                                System.out.println(d.getSpecificConsumptionDetails(userId,"Electricity"));
                                                System.out.println(d.getSuggestedOptimizedGoal(userId,"Electricity",9000)); //DP based on Graph

                        /*------------user can opt to re-calibrating his target ---------------------------------------------------*/
                                                d.modifyGoal(userId,"Electricity","PowerSupply", 600);

                        /*------------user can opt to schedule Washing Machine ---------------------------------------------------*/
                                                //d.scheduleFlexibleAppliance(userId,"Electricity", "WashingMachine", new Time(11,30,20));


            }



    /* *********************************************
       <TODO> : Implement following Business Methods
       =============================================
         --remmoveAppliance()
         --getTargetGoal()
         --getProjectSavings()
         --getBadgesAndIncentives()
         --calculateDeviation()
         --getSuggestedOptimizedGoals("Electric") DP based on Graph
    */
    /*----Constructor-------------*/
            public DesignHECA(){ init(); }


    /*----Utility & Loaders-------*/
            public void init() {    }   //can be populated from File system


}

enum ApplianceType{
    STRICT, FLEXIBLE;
}
enum Goal{
    EXCELLENT,GOAL_ACHIEVED,EXCEEDED;
}
enum Badge{


        // Badge with Incentive
            COPPER(100),SILVER(300),GOLD(800);

            private int intValue;
            private String abbreviation;

            private Badge(final int intValue) {
                this.intValue = intValue;
            }
            private Badge(String value) {
                this.abbreviation = value;
            }
        //lookup a Java enum from its ordinals
            private static Badge[] values = Badge.values();
            public static Badge getByID(int i) {
                    return (values[i - 1] != null)? values[i - 1] : Badge.values()[i];
            }

}


enum Score{
    CONSUMES_LOW, CONSUMES_MEDIUM, CONSUMES_HIGH, CONSUMES_PEAK;
}

@lombok.Data
public class Appliance {
    private final String applianceCategory; //e.g Electricity
    private final ApplianceType applianceType; //e.g StrictAppliance like Refrigerator
    private final String applianceName; //e.g WashingMachine
    private final int usageTime;
    private final Time scheduledTime;
}

data class Appliance(
    val category: String, //e.g Electricity
    val type: ApplianceType, //e.g StrictAppliance like Refrigerator
    val name: String, //e.g WashingMachine
    val usageTime: int,
    val scheduledTime: Time)

new Attribute("WindPower", 3.4, 13, 500)

Appliance(
        category = "Electricity",
        type = ApplianceType.StrictAppliance,
        name = "WashingMachine",
        usageTime = 13,
        scheduledTime = Time(1234L))