import os
import concurrent.futures
import logging
import queue
import random
import subprocess
import time
import pandas as pd
import re, csv
import matplotlib
import argparse
import numpy as np
import configuration_file as config
import precice
from precice import *
# import openseespy.opensees as ops
# import openseespy.postprocessing.ops_vis as opsv
# from startOpenSees.py import *
import logging
import sys
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)





#os.system('pyFoamClearCase.py .')

#########################################################################################
e_mod = 2.0e11
i_sect = 200.0
area = 2.5
lp_i = 0.1
lp_j = 0.1

nodalmass=1e4
nycells=100

timestepCount=1
plotoption=1
df = pd.DataFrame(columns=["T","FX","FY","X Force Residual","Y Force Residual","ExpectedDisplacement","XDisplacement","YDisplacement"])

static=0

OpenFOAM_dt =.005

beamL=10

elementsInBeam=12 # >20

yloc=0.01

DriverT=0

thickness=.01

density=1000

hgt=1

fsiPatch="interface"

############################## End of (Nikki Defined) Settings #######################

print("Starting Structure Solver...")
    
parser = argparse.ArgumentParser()
parser.add_argument("configurationFileName", help="Name of the xml config file.", nargs='?', type=str,
                    default="precice-config-Py-OF.xml")

try:
    args = parser.parse_args()
except SystemExit:
    print("")
    print("Did you forget adding the precice configuration file as an argument?")
    print("Try '$ python Solid1Solver.py precice-config-Py-OF.xml'")
    quit()

configFileName = args.configurationFileName

N = elementsInBeam # number of elements

print("N: " + str(N))

solverName = "Solid1"

print("Configure preCICE...")
interface = precice.Interface(solverName, configFileName, 0, 1)
print("preCICE configured...")

dimensions = interface.get_dimensions()

Solid1_Nodes=[[beamL*(1/elementsInBeam)*c,yloc*(1/elementsInBeam)*.01,0.00] for c in range(0,elementsInBeam+1)]
initialDisplacements=[[0.0,0.0,0.0] for node_num in range(len(Solid1_Nodes))]

pressure = config.p0 * np.ones(N + 1) # initial pressure
displacement = initialDisplacements


print("Structure: init precice...")

# preCICE defines timestep size of solver via precice-config.xml
precice_dt = interface.initialize()

meshID = interface.get_mesh_ids("Solid1-Mesh")
displacementID = interface.get_data_id("Displacement", meshID)
pressureID = interface.get_data_id("Pressure", meshID)

vertexIDs = np.zeros(N + 1)
Solid1_Mesh = np.zeros([N + 1, dimensions])

Solid1_Mesh[:, 0] = np.linspace(0., beamL, N + 1)  # x component
Solid1_Mesh[:, 1] = 0.*np.linspace(0., beamL, N + 1)  # np.linspace(0, config.L, N+1)  # y component, leave blank
Solid1_Mesh[:, 2] = 0.*np.linspace(0., beamL, N + 1)  # np.linspace(0, config.L, N+1)  # z component, leave blank

vertexIDs = interface.set_mesh_vertices(meshID, Solid1_Mesh)

fixity=[[0,0,0,0,0,0] for _ in range(0,len(Solid1_Nodes))]

fixity[0]= [1,1,1,1,1,1]
fixity[elementsInBeam]= [1,1,1,1,1,1]

orientation=[[0, 0, 1] for _ in range(0,elementsInBeam)]

# Sees=OpenSeesPyInstance(self.OpenSees_dt, self.e_mod, self.i_sect, self.area, self.lp_i, self.lp_j, self.nodalmass, self.Solid1_Mesh, fixity, orientation)

t = 0


if interface.is_action_required(action_write_initial_data()):
    interface.write_block_vector_data(displacementID, vertexIDs, displacement)
    interface.mark_action_fulfilled(action_write_initial_data())

interface.initialize_data()

if interface.is_read_data_available():
    pressure = interface.read_block_scalar_data(pressureID, vertexIDs)

displacement0 = initialDisplacements
pressure0 = config.p0 * np.ones_like(pressure)

while interface.is_coupling_ongoing():
    # When an implicit coupling scheme is used, checkpointing is required
    if interface.is_action_required(action_write_iteration_checkpoint()):
        interface.mark_action_fulfilled(action_write_iteration_checkpoint())

    # TO DO 
    # READ PRESSURES OUT FROM OF AND MAP TO OPENSEES
    # OUTPUT THE DISPLACEMENTS INTO THE FOLLOWING VARIABLE, displacement
    #Sees.stepForward()
    displacement = displacement0
	#displacement = Sees.displacement
    interface.write_block_vector_data(displacementID, vertexIDs, displacement)
    # precice_dt = interface.advance(precice_dt)
    #Sees.pressure = interface.read_block_scalar_data(pressureID, vertexIDs)
    
    if interface.is_action_required(action_read_iteration_checkpoint()):  # i.e. not yet converged
        interface.mark_action_fulfilled(action_read_iteration_checkpoint())
    else:
        t += precice_dt

print("Exiting StructureSolver")

interface.finalize()