# *********************************************
# Importing needed Libraries from Python
# *********************************************
from __future__ import division
import pandas
import string
import locale
import os
import lookup
from datetime import datetime
import StringIO
import pickle

import numpy as np
import time
from pytz import timezone
import json
import sys
import re
import csv

import math
import ModifySpotLoad
import LoadFlowOverload
import UserInput
from ModifySpotLoad import open_study

pacific = timezone('US/Pacific')

# *********************************************
# Importing CYMPY Library from CYME EXE Folder
# *********************************************
CYMPY_LOCATION = r"C:\Program Files (x86)\CYME\CYME"
sys.path.insert(1, CYMPY_LOCATION)
import cympy
import cympy.rm
import cympy.db
import cympy.eq

import function_study_analysis
from definitions import *
import random

# *********************************************
# Opening Self Contained File from directory
# *********************************************

from pandas.core.frame import DataFrame
#Exporting EVSE demand profiles from CSV to Python
#path is the computer address
path = "C:\\Users\\pwrlab07\\Downloads\\PEV-Profiles-L1.csv"

#Places CSV into the a list of columns with a special format, which skips household and vehicle titles
MDataL1 = pandas.read_csv(path, skiprows=2)
L1Store=[]
DeviceTimeStep=[]
for value in MDataL1['Time']:
    DeviceTimeStep.append(value)

#This converts the list above into a standard format, first index column number, second index time step
for val in MDataL1.columns:
    if val != 'Time':
        df=MDataL1[val]
        L1Store.append(df)

path = "C:\\Users\\pwrlab07\\Downloads\\PEV-Profiles-L2.csv"
MDataL2 = pandas.read_csv(path, skiprows=2)
L2Store=[]

for val in MDataL2.columns:
    if val != 'Time':
        df=MDataL2[val]

        L2Store.append(df)
IntProfile=[[],[],[],[],[]]

i=0
for address in int_demandprofiles:

    IntProf = pandas.read_csv(address, skiprows=1)

    IntProfile[i]=[IntProf[IntProf.columns[1]],IntProf[IntProf.columns[2]],IntProf[IntProf.columns[3]]]

    i=i+1

#Chance of EVSE between Level 1 and Level 2, which can be changed
L1_chance = 90
L2_chance = 10

#Function asking if the User wants to use a different Level 1 and Level 2 composition
L1_chance, L2_chance= UserInput.ChargerDecisions(L1_chance, L2_chance)

#Asks user for number of devices to keep track of, Currently not in use along with related function
HowMany=UserInput.HowManyWorst()

#Assigns and creates storage for number of vehicles each customer and other records based off house power consumption
CustVehicleStorage, new_filename, spotlist_through,CarsFull=ModifySpotLoad.HouseholdVehicles(model_filename, L1_chance, L2_chance)


#Gets the number of invalid devices, signified by a QueryInfoDevice charactor of  ''
#This retrieves Asset BassNulls before adding intentional loads
BaseXfmrNull_Base, BaseXfmrByPhaseNull_Base, BaseLineNull_Base, XfmrNullName, XfmrByPhaseNullName, LineNullName = LoadFlowOverload.BaseNulls(new_filename)

#Intentional Load asks the user if there are specific larger EV loads they're adding, and adds them
Current_Filename, LaterStorage, AppliedNames, UnAppliedNames, NamesAll= ModifySpotLoad.IntentionalLoad(new_filename, IntProfile)

LoadTimeXfmrSingle = []
LoadTimeByPhaseSingle = []
LoadTimeTransSingle = []

#Asks for the penetrations used for this study
Current_Filename, CurPen, MaxVal, IntValPen,CustVehicleStorage, Applied, Type,AppliedCars, NamesApplied,AppliedNames, UnAppliedNames =UserInput.CurrentPen(Current_Filename, L1_chance, L2_chance,CustVehicleStorage, spotlist_through, LaterStorage, L1Store, L2Store,AppliedNames, UnAppliedNames)

#Another access of BaseNulls, to pull invalid devices after intentional load addition
BaseXfmrNull, BaseXfmrByPhaseNull, BaseLineNull ,XfmrNullName, XfmrByPhaseNullName, LineNullName= LoadFlowOverload.BaseNulls(Current_Filename)

#Checks to make sure there were no changes from the base study, to the study with intentional loads added brought to the
#Current EV penetration
if BaseXfmrNull_Base != BaseXfmrNull or BaseXfmrByPhaseNull_Base != BaseXfmrByPhaseNull or BaseLineNull_Base != BaseLineNull:
    print 'Your intentional load additions have caused load flow errors'
    print 'I\'m not sure why this would happen, possibly due to too large of a load added'
    exit()

data_overload_precent=[]
IntentionalLoadingStorage=[]
IntappliedStorage=[]

start_main1=datetime.now()

#Ensures Penetration value are integers, then creates range of EV Penetration used
CurPen=int(CurPen)
MaxVal=int(MaxVal)
IntValPen=int(IntValPen)
Penetration = range((CurPen), (MaxVal + 1), IntValPen)

end_main1=datetime.now()
print('Main script part 1 Done in ' + str((end_main1 - start_main1).total_seconds()) + ' seconds')
#Opens study to grab device names
cympy.study.Open(Current_Filename)
start_devices=datetime.now()

#Grabs lists of all devices of the types specified, for grabbing their names, these values are used in each function
#due to modifications changing the order of .list_devices
xfmr = function_study_analysis.list_devices(cympy.enums.DeviceType.Transformer)
xfmr_byphase = function_study_analysis.list_devices(cympy.enums.DeviceType.TransformerByPhase)
xfmr_cable = function_study_analysis.list_devices(cympy.enums.DeviceType.OverheadByPhase)
end_devices=datetime.now()
print('Three main list_devices PGE Done in ' + str((end_devices - start_devices).total_seconds()) + ' seconds')

xfmrStorage = []
xfmr_byphaseStorage = []
xfmr_cableStorage = []

cympy.study.Close(False)

OldPen=CurPen
IntVal=0
aplace=0

#StartTime dictates the range of timesteps to use, Maximum time step value 52559, Dec 31st 23:50
# 0=Jan 1st 2018, 00:00, 1=Jan 1st 2018, 00:10, 72=Jan 1st 2018, 12:00, 144=Jan 2nd 2018, 00:00
startTime=int(raw_input('When should this test begin?(1=10 minutes, 6=hour, 144=day):'))
MaxTime=int(raw_input('How many time steps would you like to use?(1=10 minutes, 6=hour, 144=day):'))

DeviceTimeStepPart=DeviceTimeStep[startTime:MaxTime+startTime]

start_full_loop=datetime.now()

if Applied == 1:
    skip=1
LoadTimeXfmrPen = []
LoadTimeByPhasePen = []
LoadTimeTransPen = []
LoadTimeXfmrVoltPen = []
LoadTimeByPhaseVoltPen = []
LoadTimeTransVoltPen = []
LoadTimeByPhaseVoltExtraPen = []
LoadTimeIntByPhasePen = []
LoadTimeIntByPhaseVoltPen = []
LoadTimeByPhaseVoltDropPen = []
LoadTimeTransVoltDropPen = []
LoadTimeXfmrVoltOutPen=[]
#Main tool loop, loops through each penetration level, using LoadGrowth to connect penetration to device year
#Stocastically decides which customer load will recieve an EV
for Pen in Penetration:
    LoadTimeXfmrMany = []
    LoadTimeByPhaseMany = []
    LoadTimeTransMany = []
    LoadTimeXfmrVoltMany = []
    LoadTimeByPhaseVoltMany = []
    LoadTimeByPhaseVoltExtraMany = []
    LoadTimeTransVoltMany = []
    LoadTimeTransVoltExtraMany = []
    LoadTimeIntByPhaseVoltMany = []
    LoadTimeByPhaseVoltDropMany = []
    LoadTimeTransVoltDropMany = []
    LoadTimeXfmrVoltOutMany=[]
    BrokenStudy=0
    start_loop=datetime.now()
    reset=1

    #Calculating the real penetration, 100-float(oldpen) = Current percentage of Cars with EV spots open
    #As an example, from 95% penetration to 100% penetration, all possible EV's would have to be added, which means
    #100% EV application for Add_EV
    #Another exmaple, 90% to 95%, adding 5% of EV's off of the 10 remaining % wouldn't be 5%, it would be 50%
    if Applied == 1:
        RealPen=float(IntValPen)/(100.0-float(OldPen))*100

    elif Applied == 2:
        RealPen=float(IntValPen)/(100.0-(float(OldPen)-float(CurPen)))*100

    #Storage for the filename in case of a Validity failure later on
    Old_Filename=Current_Filename

    #reset represents wether the system was determined to be valid or not, it starts as 0, and only become 1 after
    #a validity failure in LoadFlowOverload.loadflow
    while reset == 1:
        start_EV=datetime.now()

        #Add_EV takes the study, looks through it for avaliable areas for EV application, and places them
        if skip != 1:
            Current_Filename, CustVehicleStorage, SpotnumOrder, AppliedCars, NamesApplied,LaterStorage,AppliedNames, UnAppliedNames=ModifySpotLoad.Add_EV(Old_Filename,L1_chance,L2_chance,RealPen,model_filename,Pen,CustVehicleStorage,spotlist_through, Type, LaterStorage, L1Store, L2Store,AppliedNames, UnAppliedNames)
        else:
            ModifySpotLoad.open_study(Old_Filename)

        end_EV=datetime.now()
        print('Add_EV Done in ' + str((end_EV - start_EV).total_seconds()) + ' seconds')
        start_OL=datetime.now()

        #ValidityCheck looks to see if recent additions have invalidated load flow
        reset=LoadFlowOverload.ValidityCheck(xfmr,xfmr_byphase,xfmr_cable, BaseXfmrNull, BaseXfmrByPhaseNull, BaseLineNull)

        end_OL=datetime.now()
        print('Overloads Done in ' + str((end_OL - start_OL).total_seconds()) + ' seconds')

        #Prints some times signifying validity error
        if reset == 1:
            print 'Well I guess there were big enough problems for an EV re-application'
            BrokenStudy = BrokenStudy + 1

            #If the study fails too many times ends the code, finding it to be an unsolvable problem
            if BrokenStudy == 5:
                print 'There are significant problems, Load Flow can\'t be completed'
                print 'This may be due to intensity of load growth making the system incapable of supplying the loads'
                exit()

    #If the last study wasn't broken
    if reset != 1:
        ModifySpotLoad.open_study(Current_Filename)
        num=0
        for j in range(startTime, MaxTime+startTime):
            j_int=j-startTime

            start = datetime.now()
            #ReApply applied the current demand profile of EVSE added previously
            NameReapply=ModifySpotLoad.ReApply(Current_Filename, CustVehicleStorage, j, L1Store, L2Store, AppliedNames, j_int)

            end = datetime.now()
            print('ModifySpotload Done in ' + str((end - start).total_seconds()) + ' seconds')
            start = datetime.now()

            #TimeFlow looks into the overloads that are readable after a load flow simulation
            LoadTimeXfmrSingle,LoadTimeByPhaseSingle,LoadTimeTransSingle,LoadTimeXfmrVoltSingle,LoadTimeByPhaseVoltSingle,LoadTimeTransVoltSingle,num,LoadTimeIntByPhaseSingle ,LoadTimeIntByPhaseVoltSingle, LoadTimeByPhaseVoltExtraSingle,LoadTimeTransVoltExtraSingle,LoadTimeByPhaseVoltDropSingle,LoadTimeTransVoltDropSingle, LoadTimeXfmrVoltOutSingle =LoadFlowOverload.TimeFlow(j,num,xfmr,xfmr_byphase,xfmr_cable,AppliedNames,UnAppliedNames,NamesAll)
            end = datetime.now()
            print('TimeFlow Done in ' + str((end - start).total_seconds()) + ' seconds')

            #Gathers Loading and Voltage values for each time step
            if LoadTimeXfmrMany == []:

                LoadTimeXfmrMany = [LoadTimeXfmrSingle]
                LoadTimeByPhaseMany = [LoadTimeByPhaseSingle]
                LoadTimeTransMany = [LoadTimeTransSingle]
                LoadTimeXfmrVoltMany = [LoadTimeXfmrVoltSingle]
                LoadTimeByPhaseVoltMany = [LoadTimeByPhaseVoltSingle]
                LoadTimeByPhaseVoltExtraMany = [LoadTimeByPhaseVoltExtraSingle]
                LoadTimeTransVoltMany = [LoadTimeTransVoltSingle]
                LoadTimeTransVoltExtraMany = [LoadTimeTransVoltExtraSingle]
                LoadTimeIntByPhaseMany = [LoadTimeIntByPhaseSingle]
                LoadTimeIntByPhaseVoltMany = [LoadTimeIntByPhaseVoltSingle]
                LoadTimeByPhaseVoltDropMany=[LoadTimeByPhaseVoltDropSingle]
                LoadTimeXfmrVoltOutMany = [LoadTimeXfmrVoltOutSingle]

            else:
                LoadTimeXfmrMany = LoadTimeXfmrMany+[LoadTimeXfmrSingle]
                LoadTimeByPhaseMany = LoadTimeByPhaseMany+[LoadTimeByPhaseSingle]
                LoadTimeTransMany = LoadTimeTransMany+[LoadTimeTransSingle]
                LoadTimeXfmrVoltMany = LoadTimeXfmrVoltMany+[LoadTimeXfmrVoltSingle]
                LoadTimeByPhaseVoltMany = LoadTimeByPhaseVoltMany+[LoadTimeByPhaseVoltSingle]
                LoadTimeByPhaseVoltExtraMany = LoadTimeByPhaseVoltExtraMany+[LoadTimeByPhaseVoltExtraSingle]
                LoadTimeTransVoltMany = LoadTimeTransVoltMany + [LoadTimeTransVoltSingle]
                LoadTimeTransVoltExtraMany = LoadTimeTransVoltExtraMany + [LoadTimeTransVoltExtraSingle]
                LoadTimeIntByPhaseMany = LoadTimeIntByPhaseMany + [LoadTimeIntByPhaseSingle]
                LoadTimeIntByPhaseVoltMany = LoadTimeIntByPhaseVoltMany + [LoadTimeIntByPhaseVoltSingle]
                LoadTimeByPhaseVoltDropMany=LoadTimeByPhaseVoltDropMany+[LoadTimeByPhaseVoltDropSingle]
                LoadTimeXfmrVoltOutMany = LoadTimeXfmrVoltOutMany+[LoadTimeXfmrVoltOutSingle]

        #Each Penetration appends results to per penetration list
        if LoadTimeXfmrPen == []:
            LoadTimeXfmrPen = [[Pen]+[LoadTimeXfmrMany]]
            LoadTimeByPhasePen = [[Pen]+[LoadTimeByPhaseMany]]
            LoadTimeTransPen = [[Pen]+[LoadTimeTransMany]]
            LoadTimeXfmrVoltPen = [[Pen]+[LoadTimeXfmrVoltMany]]
            LoadTimeByPhaseVoltPen = [[Pen]+[LoadTimeByPhaseVoltMany]]
            LoadTimeByPhaseVoltExtraPen = [[Pen] + [LoadTimeByPhaseVoltExtraMany]]
            LoadTimeTransVoltPen = [[Pen]+[LoadTimeTransVoltMany]]
            LoadTimeTransVoltExtraPen = [[Pen] + [LoadTimeTransVoltExtraMany]]
            LoadTimeIntByPhasePen = [[Pen] + [LoadTimeIntByPhaseMany]]
            LoadTimeIntByPhaseVoltPen = [[Pen] + [LoadTimeIntByPhaseVoltMany]]
            LoadTimeByPhaseVoltDropPen = [[Pen]+[LoadTimeByPhaseVoltDropMany]]
            LoadTimeXfmrVoltOutPen = [[Pen]+[LoadTimeXfmrVoltOutMany]]

        else:
            LoadTimeXfmrPen = LoadTimeXfmrPen + [[Pen]+[LoadTimeXfmrMany]]
            LoadTimeByPhasePen = LoadTimeByPhasePen+ [[Pen]+[LoadTimeByPhaseMany]]
            LoadTimeTransPen = LoadTimeTransPen+ [[Pen]+[LoadTimeTransMany]]
            LoadTimeXfmrVoltPen = LoadTimeXfmrVoltPen + [[Pen]+[LoadTimeXfmrVoltMany]]
            LoadTimeByPhaseVoltPen = LoadTimeByPhaseVoltPen + [[Pen]+[LoadTimeByPhaseVoltMany]]
            LoadTimeByPhaseVoltExtraPen = LoadTimeByPhaseVoltExtraPen + [[Pen] + [LoadTimeByPhaseVoltExtraMany]]
            LoadTimeTransVoltPen = LoadTimeTransVoltPen + [[Pen]+[LoadTimeTransVoltMany]]
            LoadTimeTransVoltExtraPen = LoadTimeTransVoltExtraPen + [[Pen] + [LoadTimeTransVoltExtraMany]]
            LoadTimeIntByPhasePen = LoadTimeIntByPhasePen + [[Pen] + [LoadTimeIntByPhaseMany]]
            LoadTimeIntByPhaseVoltPen = LoadTimeIntByPhaseVoltPen + [[Pen] + [LoadTimeIntByPhaseVoltMany]]
            LoadTimeByPhaseVoltDropPen = LoadTimeByPhaseVoltDropPen+[[Pen]+[LoadTimeByPhaseVoltDropMany]]
            LoadTimeXfmrVoltOutPen = LoadTimeXfmrVoltOutPen+ [[Pen] + [LoadTimeXfmrVoltOutMany]]

    skip = 0
    OldPen=Pen

    end_loop=datetime.now()
    print('Single Loop Done in ' + str((end_loop - start_loop).total_seconds()) + ' seconds {Pen}'.format(Pen=Pen))

cympy.study.Close(False)
TimeRange=range(startTime,MaxTime+startTime)
Xfmrvalue,XfmrWorst,XfmrVoltvalue, ByPhasevalue,ByPhaseWorst, ByPhaseVoltvalue,Cablevalue,CableWorst ,CableVoltvalue, XfmrHist,ByPhaseHist,FullVoltage, GraphStorage,IntByPhasevalue,IntByPhaseWorst, IntByPhaseVoltvalue,IntByPhaseHist, VoltageTrendStore, LoadingTrendStore,XfmrExcelHM,XfmrVoltExcelHM,XfmrHistHM,ByPhaseExcelHM,ByPhaseVoltExcelHM,ByPhaseHistHM,IntByPhaseExcelHM,IntByPhaseVoltExcelHM,IntByPhaseHistHM,CableExcelHM,CableVoltExcelHM,CableHistHM,ByPhaseVoltDropvalue,CableVoltDropvalue, XfmrVoltOutExcel =LoadFlowOverload.Processing(LoadTimeXfmrPen, LoadTimeByPhasePen, LoadTimeTransPen, TimeRange,LoadTimeXfmrVoltPen, LoadTimeByPhaseVoltPen, LoadTimeTransVoltPen, LoadTimeIntByPhasePen,LoadTimeIntByPhaseVoltPen, NamesAll, HowMany,LoadTimeByPhaseVoltDropPen,LoadTimeTransVoltDropPen, LoadTimeXfmrVoltOutPen)

LoadFlowOverload.CSVOutputsTime2(Penetration,Xfmrvalue,XfmrWorst, ByPhasevalue,ByPhaseWorst, Cablevalue,CableWorst, XfmrVoltvalue,ByPhaseVoltvalue,CableVoltvalue, XfmrHist,ByPhaseHist,FullVoltage,GraphStorage,IntByPhasevalue,IntByPhaseWorst, IntByPhaseVoltvalue,IntByPhaseHist, VoltageTrendStore, LoadingTrendStore, NamesAll, TimeRange,XfmrExcelHM,XfmrVoltExcelHM,XfmrHistHM,ByPhaseExcelHM,ByPhaseVoltExcelHM,ByPhaseHistHM,IntByPhaseExcelHM,IntByPhaseVoltExcelHM,IntByPhaseHistHM,CableExcelHM,CableVoltExcelHM,CableHistHM,DeviceTimeStepPart, ByPhaseVoltDropvalue,CableVoltDropvalue, XfmrVoltOutExcel)



exit()

# *********************************************
# ************ T H E   E N D ******************
# *********************************************