import pickle
import random
import sys
from math import pow
from math import floor
from math import ceil
import cplex
import time

timeS = time.clock()
print "time start:",timeS

##f = open("OPL3v1r4m.pck","r")
##f = open("OPL3v1r6m.pck","r")
##f = open("OPL5v2r4m.pck","r")
##f = open("OPL5v2r6m.pck","r")
##f = open("OPL10v3r4m.pck","r")
f = open("OPL10v3r6m.pck","r")
##f = open("OPL24v5r4m.pck","r")
##f = open("OPL24v5r6m.pck","r")

time1 = time.clock()

### loading all data from the datafile----------------:
## This data file is created as a pickle file from another python code
## may not be a good method to handle data, but that's what I do
Te = pickle.load(f)
T = tuple(pickle.load(f))
T0 = tuple(pickle.load(f))
Vn = pickle.load(f)
V = tuple(pickle.load(f))
Rn = pickle.load(f)
R = tuple(pickle.load(f))
Rv = tuple(pickle.load(f))
Vr = tuple(pickle.load(f))
P = tuple(pickle.load(f))
Pr = tuple(pickle.load(f))
PrO = tuple(pickle.load(f))
PrD = tuple(pickle.load(f))
Rp = tuple(pickle.load(f))
Ir = tuple(pickle.load(f))
Cr = tuple(pickle.load(f))
RP = pickle.load(f)

Crp = pickle.load(f) #DICT
CrpO = pickle.load(f) #DICT
CrpD = pickle.load(f) #DICT

Vcap = tuple(pickle.load(f))
RPCT = pickle.load(f)
RPC0 = pickle.load(f)
RPCT0 = pickle.load(f)

Prpct = pickle.load(f) #DICT

RPC = pickle.load(f)
IOrpc = tuple(pickle.load(f))
Ip = tuple(pickle.load(f))
VRP = pickle.load(f)
Tvrp = tuple(pickle.load(f))
VR = pickle.load(f)
TOvr = tuple(pickle.load(f))
Tvr = tuple(pickle.load(f))
COvr = tuple(pickle.load(f))
CEvr = tuple(pickle.load(f))
VRQ = pickle.load(f)
TBvrq = tuple(pickle.load(f))
Cvrq = tuple(pickle.load(f))
RI = pickle.load(f)
TWri = tuple(pickle.load(f))
CSri = pickle.load(f)
CpenS = pickle.load(f)
CpenE = pickle.load(f)

Nv = pickle.load(f) #DICT
Nvo = pickle.load(f) #DICT
Nvd = pickle.load(f) #DICT
Nvall = pickle.load(f) #DICT
Aov = pickle.load(f) #DICT
Adv = pickle.load(f) #DICT
Amidv = pickle.load(f) #DICT
Av = pickle.load(f) #DICT
Anonorigv = pickle.load(f) #DICT
Aendv = pickle.load(f) #DICT
Aorigv = pickle.load(f) #DICT
Adestv = pickle.load(f) #DICT

VA = pickle.load(f)
VRPCT = pickle.load(f)
VT = pickle.load(f)

Cva = pickle.load(f)

PrcLD = pickle.load(f) #DICT

Avritd = pickle.load(f) #DICT-(v,r,i,t) - cons3
Avrito = pickle.load(f) #DICT - (v,r,i,t)
Avri = pickle.load(f) #DICT - (v,r,i) - cons4
Avrpt = pickle.load(f) #DICT - (v,r,p,t) - cons5


f.close()

ncargo = 0
for r in R:
    ncargo += len(Cr[r-1])
print "No. Cargoes = ",ncargo

#Three periods: lf = Freeze period; lp = planned period; lc = forecast period
lf = 30
lp = 30
lc = 30
VAt = [[] for t in T]
for t in T:
    VAt[t-1] = [va for va in VA if va[1][1][2]==t]

time2 = time.clock()
print "# Time to load data: ",
print (time2 - time1),
print "secs"


##time3 = time.clock()

Scost = 0
for ri in RI:
    iri = RI.index(ri)
    Scost += CSri[iri]

##time4 = time.clock()
##time5 = time.clock()
##print "#(Time check: ",
##print (time5 - time4),
##print "secs"

## MIP model initiation:-------------------------------------------------
## Defining MIP subproblem:
cpx = cplex.Cplex()
cpx.parameters.read.datacheck.set(1)
cpx.parameters.workmem.set(30000.0)
nm = int(floor(Te/30))
itrhrs = int(ceil(24/nm))
print "itrhrs=",itrhrs
cpx.parameters.timelimit.set(itrhrs*60*60)
##cpx.parameters.mip.tolerances.mipgap.set(0.01)

### Decision vars
var_x = ["x_"+str(va) for va in VA]
var_q = ["q_"+str(vrpct) for vrpct in VRPCT]
var_i = ["i_"+str(rpct) for rpct in RPCT0]
var_l = ["l_"+str(vt) for vt in VT]
var_iE = ["iE_"+str(rpct) for rpct in RPCT0]
var_iS = ["iS_"+str(rpct) for rpct in RPCT0]

var_names = var_x + var_q + var_i+ var_l + var_iE + var_iS
var_names_nox = var_q + var_i+ var_l + var_iE + var_iS

my_obj = Cva + [0]*len(var_q) + [0]*len(var_i) + [0]*len(var_l) + [CpenE]*len(var_iE) + [CpenS]*len(var_iS)

ub_q = []
ub_i = []
ub_l = []
ub_iE = []
ub_iS = []

for vrpct in VRPCT:
    v = vrpct[0]
    r = vrpct[1]
    p = vrpct[2]
    c = vrpct[3]
    t = vrpct[4]
    ub_q.append(Vcap[v-1])
for rpct in RPCT0:
    r = rpct[0]
    p = rpct[1]
    c = rpct[2]
    t = rpct[3]
    ub_i.append(Ip[p-1])

for vt in VT:
    v = vt[0]
    t = vt[1]
    ub_l.append(Vcap[v-1])

my_ub = [1]*len(var_x) + ub_q + ub_i + ub_l + [99999]*len(var_iE) + [99999]*len(var_iS)
my_lb = [0]*len(var_x) + [0]*len(var_names_nox)

cpx.objective.set_sense(cpx.objective.sense.minimize)

cpx.variables.add(obj = my_obj, names = var_names,ub=my_ub,lb=my_lb)

time3 = time.clock()
print "#Time to initialize variables etc.: ",
print (time3 - time2),
print "secs"
ctr = 0
## Constraints:

#Cons1:-----------------------------------------------
for v in V:
    var = ["x_"+str((v,a)) for a in Aorigv[v]]
    val = [1.0]*len(var)
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [1])
    ctr += 1

time4 = time.clock()
print "#Time to load Cons1: ",
print (time4 - time3),
print "secs",
print "--ctr:",ctr
#Cons2:-------------------------------------------------
for v in V:
    var = ["x_"+str((v,a)) for a in Adestv[v]]
    val = [1.0]*len(var)
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [1])
    ctr += 1

time5 = time.clock()
print "#Time to load Cons2: ",
print (time5 - time4),
print "secs",
print "--ctr:",ctr
#Cons3:------------Long Time-------------------------------------
for v in V:
    for rit in Nv[v]:
        r = rit[0]
        i = rit[1]
        t = rit[2]
        var1 = ["x_"+str((v,a)) for a in Avritd[(v,r,i,t)] ]
        var2 = ["x_"+str((v,a)) for a in Avrito[(v,r,i,t)] ]
        var = var1 + var2
        val = [1]*len(var1) + [-1]*len(var2)
        cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [0])
        ctr += 1

time6 = time.clock()
print "#Time to load Cons3: ",
print (time6 - time5),
print "secs",
print "--ctr:",ctr
#Cons4:-------------------------------------------------
for ri in RI:
    r = ri[0]
    i = ri[1]
    var = ["x_"+str((v,a)) for v in Vr[r-1] for a in Avri[(v,r,i)] ]
    val = [1]*len(var)
    #+=1
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["L"],rhs = [1.0])
    ctr += 1

time7 = time.clock()
print "#Time to load Cons4: ",
print (time7 - time6),
print "secs",
print "--ctr:",ctr
#Cons5:---------------Very Long Time----------------------------------
for vrpct in VRPCT:
    v = vrpct[0]
    r = vrpct[1]
    p = vrpct[2]
    c = vrpct[3]
    t = vrpct[4]
    i_vrp = VRP.index((v,r,p))
    var1 = ["q_"+str(vrpct)]
    val1 = [1]
    var2 = ["x_"+str((v,a)) for a in Avrpt[(v,r,p,t)] ]
    val2 = [-Vcap[v-1]]*len(var2)
    var = var1+var2
    val = val1+val2
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["L"],rhs = [0.0])
##    if ctr%100 == 0:
##        print "k-",
##    ctr += 1

time8 = time.clock()
print "#Time to load Cons5: ",
print (time8 - time7),
print "secs",
print "--ctr:",ctr
#Cons6:-------------------------------------------------
for v in V:
    for r in Rv[v-1]:
        for c in Cr[r-1]:
            po = PrcLD[(r,c)][0]
            pd = PrcLD[(r,c)][1]
            i_vrpo = VRP.index((v,r,po))
            i_vrpd = VRP.index((v,r,pd))
            for t in T:
                t1 = t + int(floor(Tvrp[i_vrpd]-Tvrp[i_vrpo]))
                if t1 <= 120:
                    var = ["q_"+str((v,r,po,c,t))] + ["q_"+str((v,r,pd,c,t1))] 
                    val = [1,-1]
                    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [0.0])
                    ctr += 1
 
time9 = time.clock()
print "#Time to load Cons6: ",
print (time9 - time8),
print "secs",
print "--ctr:",ctr
#Cons7:-------------------------------------------------
for rpc0 in RPC0:
    r = rpc0[0]
    p = rpc0[1]
    c = rpc0[2]
    i_rpc = RPC.index((r,p,c))
    var = ["i_"+str(rpc0)]
    val = [1]
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [IOrpc[i_rpc]])
    ctr += 1

time10 = time.clock()
print "#Time to load Cons7: ",
print (time10 - time9),
print "secs",
print "--ctr:",ctr
#Cons8:-----------------Long Time--------------------------------
for r in R:
    for p in PrO[r-1]:
        for c in CrpO[(r,p)]:
            for t in T:
                var1 = ["i_"+str((r,p,c,t-1))]
                val1 = [1]
                var2 = ["q_"+str((v,r,p,c,t)) for v in Vr[r-1]]
                val2 = [-1]*len(var2)
                var3 = ["i_"+str((r,p,c,t))]
                val3 = [-1]
                var4 = ["iE_"+str((r,p,c,t))]
                val4 = [-1]
                var5 = ["iS_"+str((r,p,c,t))]
                val5 = [1]
                var = var1+var2+var3+var4+var5
                val = val1+val2+val3+val4+val5
                cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [-Prpct[(r,p,c,t)]])
                ctr += 1

time11 = time.clock()
print "#Time to load Cons8: ",
print (time11 - time10),
print "secs",
print "--ctr:",ctr
#Cons9:----------------Long Time---------------------------------
for r in R:
    for p in PrD[r-1]:
        for c in CrpD[(r,p)]:
            for t in T:
                var1 = ["i_"+str((r,p,c,t-1))]
                val1 = [1]
                var2 = ["q_"+str((v,r,p,c,t)) for v in Vr[r-1]]
                val2 = [1]*len(var2)
                var3 = ["i_"+str((r,p,c,t))]
                val3 = [-1]
                var4 = ["iE_"+str((r,p,c,t))]
                val4 = [-1]
                var5 = ["iS_"+str((r,p,c,t))]
                val5 = [1]
                var = var1+var2+var3+var4+var5
                val = val1+val2+val3+val4+val5
                cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [Prpct[(r,p,c,t)]])
                ctr += 1

time12 = time.clock()
print "#Time to load Cons9: ",
print (time12 - time11),
print "secs",
print "--ctr:",ctr

#Cons10:-------------------------------------------------
for v in V:
    var = ["l_"+str((v,0))]
    val = [1]
    #+=1
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [0.0])
    ctr += 1

time13 = time.clock()
print "#Time to load Cons10: ",
print (time13 - time12),
print "secs",
print "--ctr:",ctr

#Cons11:-------------------------------------------------
for v in V:
    for t in T:
        var1 = ["l_"+str((v,t-1))]
        val1 = [1]
        var2 = ["q_"+str((v,r,p,c,t)) for r in Rv[v-1] for p in PrO[r-1] for c in CrpO[(r,p)]]
        val2 = [1]*len(var2)
        var3 = ["q_"+str((v,r,p,c,t)) for r in Rv[v-1] for p in PrD[r-1] for c in CrpD[(r,p)]]
        val3 = [-1]*len(var3)
        var4 = ["l_"+str(vt)]
        val4 = [-1]
        var = var1+var2+var3+var4
        val = val1+val2+val3+val4
        #+=1
        cpx.linear_constraints.add(lin_expr=[var,val],senses = ["E"],rhs = [0.0])
        ctr += 1

time14 = time.clock()
print "#Time to load Cons11: ",
print (time14 - time13),
print "secs",
print "--ctr:",ctr

#Cons12:-------------------------------------------------
for p in P:
    for t in T:
        var = ["i_"+str((r,p,c,t)) for r in Rp[p-1] for c in Crp[(r,p)]]
        val = [1]*len(var)
        cpx.linear_constraints.add(lin_expr=[var,val],senses = ["L"],rhs = [Ip[p-1]])
        ctr += 1
 
time15 = time.clock()
print "#Time to load Cons12: ",
print (time15 - time14),
print "secs",
print "--ctr:",ctr

#Cons13:-------------------------------------------------
for vt in VT:
    v = vt[0]
    var = ["l_"+str(vt)]
    val = [1]
    cpx.linear_constraints.add(lin_expr=[var,val],senses = ["L"],rhs = [Vcap[v-1]])
    ctr += 1 

time16 = time.clock()
print "#Time to load Cons13: ",
print (time16 - time15),
print "secs",
print "--ctr:",ctr

print "Time to load complete model: ",(time16-time1),"secs."
#first period model:
VA0 = []
for t in range(lf):
    VA0 += VAt[t]

cpx.variables.set_types([("x_"+str(i),cpx.variables.type.binary) for i in VA0])
X = []
cpx.solve()
stat = cpx.solution.get_status()
print "stat for first period mip:",stat
X += cpx.solution.get_values(var_x) # fixed the values of first period binaries


##-----------------------------------------------------------------------------------------------------------------
##                          RHH ALGORITHM STARTS:
##-----------------------------------------------------------------------------------------------------------------
print "************************RHH algorithm starts**********************************"
t0 = 0 #initial period
tmid = t0+lf #middle planning period
tend = tmid + lp #end relaxed period
Obj = 0
ctr = 0
while tend <= Te:
    cpx1 = cpx
    ctr+=1
    print "ctr=",ctr
    print "t0=",t0
    print "tmid=",tmid
    print "tend=",tend
    #freezing the values of the t0 period
    VA0 = []   #previous periods are already freezed..
    for t in range(t0,tmid):
        VA0 += VAt[t-1]
    VAmid = []
    for t in range(tmid,tend):
        VAmid += VAt[t-1]
    cpx.variables.set_upper_bounds([("x_"+str(i),X[VA.index(i)]) for i in VA0])
    cpx.variables.set_lower_bounds([("x_"+str(i),X[VA.index(i)]) for i in VA0])
    cpx.variables.set_types([("x_"+str(i),cpx.variables.type.binary) for i in VAmid])
    cpx.parameters.workmem.set(30000.0)
    cpx.parameters.timelimit.set(itrhrs*60*60)
    #cpx.parameters.mip.tolerances.mipgap.set(0.01)
    cpx.solve()
    stat = cpx.solution.get_status()
    Obj = cpx.solution.get_objective_value() + Scost
    print "----------------------",
    print "stat for mip:",stat,
    print "Obj:",Obj/1000000
    print "----------------------"
    X = cpx.solution.get_values(var_x)
    t0 += lf
    tmid += lf
    tend += lf
print "************************RHH algorithm ends**********************************"
#### solving for all fixed X values:
##cpx.variables.set_upper_bounds([("x_"+str(i),X[VA.index(i)]) for i in VA])
##cpx.variables.set_lower_bounds([("x_"+str(i),X[VA.index(i)]) for i in VA])
####cpx.variables.set_types([("x_"+str(i),cpx.variables.type.continuous) for i in VA])
##cpx.set_problem_type(cpx.problem_type.LP)
##cpx.solve()
##stat = cpx.solution.get_status()
##print "stat for combined problem:",stat
##Obj = cpx.solution.get_objective_value() + Scost

timeE = time.clock()
print "#(Total solution time including data capture: ",
print (timeE - timeS),
print "secs"
print "#(Total solution time only: ",
print (timeE - time16),
print "secs"

print "$$$ Final Objective = ",Obj/1000000

for i in range(len(X)):
    if X[i] > 0:
        print "X[",VA[i],"]=",X[i]

########################## MIP model ############################################################### 
print "SOLVING COMBINED MIP MODEL"
timeMIPs = time.clock()
cpx.variables.set_upper_bounds([("x_"+str(i),1) for i in VA])
cpx.variables.set_lower_bounds([("x_"+str(i),0) for i in VA])
cpx.variables.set_types([("x_"+str(i),cpx.variables.type.binary) for i in VA])
cpx.parameters.timelimit.set(24*60*60)
cpx.parameters.mip.tolerances.mipgap.set(0.001)
timeMIPd = time.clock()
print "#(Total time to update x_var bounds and change all types to binary: ",
print (timeMIPd - timeMIPs),
print "secs"
cpx.solve()
stat = cpx.solution.get_status()
Obj = cpx.solution.get_objective_value() + Scost
print "----------------------",
print "stat for mip:",stat,
print "Obj:",Obj/1000000
print "----------------------"

timeMIPe = time.clock()
print "#(Total time to solve complete MIP: ",
print (timeMIPe - timeMIPs),
print "secs"