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 sys

#os.system('pyFoamClearCase.py .')
ops.wipe()
c=-1
ct=-1
#########################################################################################
################ MORE INPUTS
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"])

beamL=10

elementsInBeam=12 # >20

yloc=0.01

DriverT=0

thickness=.01

density=1000

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()

FEnodes=[[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(FEnodes))]

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

meshID = interface.get_mesh_id("Structure_Nodes")
displacementID = interface.get_data_id("Displacement", meshID)
pressureID = interface.get_data_id("Pressure", meshID)


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

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

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

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.FEnodes, fixity, orientation)

vertexIDs = interface.set_mesh_vertices(meshID, grid)

t = 0

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

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

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 = 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()