from itertools import count
from netrc import netrc
import os
import io
from typing import *
from fastapi import FastAPI, File, UploadFile
from pydantic import BaseModel
from starlette.responses import FileResponse, JSONResponse
from fastapi import FastAPI, Response, status
from tjnetwork import *

JUNCTION = 0
RESERVOIR = 1
TANK = 2
PIPE = 1
NODE_COUNT = 0
LINK_COUNT = 2

prjs = []
inpDir = "C:/inpfiles/"
tmpDir = "C:/tmpfiles/"

if not os.path.exists(inpDir):
    os.mkdir(inpDir)

if not os.path.exists(tmpDir):
    os.mkdir(tmpDir)

app = FastAPI()

# project operations
@app.get("/haveproject/")
async def fastapi_have_project(network: str):
    return have_project(network)

@app.post("/createproject/")
async def fastapi_create_project(network: str):
    create_project(network)

    print(network)
    return network

@app.get("/isprojectopen/")
async def fastapi_is_project_open(network: str):
    return is_project_open(network)

@app.post("/openproject/")
async def fastapi_open_project(network: str):
    open_project(network)

    print(network)
    return network

@app.post("/closeproject/")
async def fastapi_close_project(network: str):
    close_project(network)
    return True

@app.post("/deleteproject/")
async def fastapi_delete_project(network: str):
    delete_project(network)
    return True

@app.post("/copyproject/")
async def fastapi_copy_project(source: str, target: str):
    copy_project(source, target)
    return True

# undo/redo
@app.post("/undo/")
async def fastapi_undo(network: str):
    undo(network)
    
    return True

@app.post("/redo/")
async def fastapi_redo(network: str):
    redo(network)
    
    return True

# node
@app.get("/getnodes/")
async def fastapi_get_nodes(network: str) -> list[str]:
    return get_nodes(network)

@app.get("/isnode/")
async def fastapi_is_node(network: str, node: str) -> bool:
    return is_node(network, node)

@app.get("/isjunction/")
async def fastapi_is_junction(network: str, node: str) -> bool:
    return is_junction(network, node)

@app.get("/isreservoir/")
async def fastapi_is_reservoir(network: str, node: str) -> bool:
    return is_reservoir(network, node)

@app.get("/istank/")
async def fastapi_is_tank(network: str, node: str) -> bool:
    return is_tank(network, node)

# link
@app.get("/getlinks/")
async def fastapi_get_links(network: str) -> list[str]:
    return get_links(network)

@app.get("/islink/")
def fastapi_is_link(network: str, link: str) -> bool:
    return is_link(network, link)

@app.get("/ispipe/")
def fastapi_is_pipe(network: str, link: str) -> bool:
    return is_pipe(network, link)

@app.get("/ispump/")
def fastapi_is_pump(network: str, link: str) -> bool:
    return is_pump(network, link)

@app.get("/isvalve/")
def is_valve(network: str, link: str) -> bool:
    return is_valve(network, link)

# curve
@app.get("/getcurves/")
def fastapi_get_curves(network: str) -> list[str]:
    return get_curves(network)

@app.get("/iscurve/")
def fastapi_is_curve(network: str, curve: str) -> bool:
    return is_curve(network, curve)

# parttern
@app.get("/getpatterns/")
def fastapi_get_patterns(network: str) -> list[str]:
    return get_patterns(network)

@app.get("/ispattern/")
def fastapi_is_curve(network: str, pattern: str) -> bool:
    return is_pattern(network, pattern)


############################################################
# junction 2.[JUNCTIONS]
############################################################

@app.post("/addjunction/")
async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
    return add_junction(network, junction, x, y, z)

@app.post("/deletejunction/")
async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
    return delete_junction(network, junction)

@app.get("/getjunctionelevation/")
async def fastapi_get_junction_elevation(network: str, junction: str) -> float:
    return get_junction_elevation(network, junction)

@app.get("/getjunctioncoord/")
async def fastapi_get_junction_coord(network: str, junction: str) -> dict[str, float]:
    return get_junction_coord(network, junction)

@app.get("/getjunctiondemand/")
async def fastapi_get_junction_demand(network: str, junction: str) -> float:
    return get_junction_demand(network, junction)

@app.get("/getjunctionpattern/")
async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
    return get_junction_pattern(network, junction)

@app.post("/setjunctionelevation/")
async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
    return set_junction_elevation(network, junction, elevation)

@app.post("/setjunctioncoord/")
async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
    return set_junction_coord(network, junction, x, y)
    
@app.post("/setjunctiondemand/")
async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
    return set_junction_demand(network, junction, demand)

@app.post("/setjunctionpattern/")
async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
    return set_junction_pattern(network, junction, pattern)


############################################################
# reservoir 3.[RESERVOIRS]
############################################################

@app.post("addreservoir/")
def fastapi_add_reservoir(name: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
    return add_reservoir(name, reservoir, x, y, head)

@app.post("/deletereservoir/")
def fastapi_delete_reservoir(name: str, reservoir: str) -> ChangeSet:
    return delete_reservoir(name, reservoir)

@app.get("/getreservoirhead/")
def fastapi_get_reservoir_head(name: str, reservoir: str) -> float | None:
    return get_reservoir_head(name, reservoir)

@app.get("/getreservoirpattern/")
def fastapi_get_reservoir_pattern(name: str, reservoir: str) -> str | None:
    return get_reservoir_pattern(name, reservoir)

@app.get("/getreservoircoord/")
def fastapi_get_reservoir_coord(name: str, reservoir: str) -> dict[str, float] | None:
    return get_reservoir_coord(name, reservoir)

@app.post("/setreservoirhead/")
def fastapi_set_reservoir_head(name: str, reservoir: str, head: float) -> ChangeSet:
    return set_reservoir_head(name, reservoir, head)

@app.post("/setreservoirpattern/")
def fastapi_set_reservoir_pattern(name: str, reservoir: str, pattern: str) -> ChangeSet:
    return set_reservoir_pattern(name, reservoir, pattern)

@app.post("/setreservoircoord/")
def fastapi_set_reservoir_coord(name: str, reservoir: str, x: float, y: float) -> ChangeSet:
    return set_reservoir_coord(name, reservoir, x, y)


############################################################
# tank 4.[TANKS]
############################################################

@app.post("/addtank/")
def fastapi_add_tank(name: str, tank: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
    return add_tank(name, tank, x, y, elevation, init_level, min_level, max_level, diameter, min_vol)

@app.post("/deletetank/")
def fastapi_delete_tank(name: str, tank: str) -> ChangeSet:
    return delete_tank(name, tank)

@app.get("/gettankelevation/")
def fastapi_get_tank_elevation(name: str, tank: str) -> float | None:
    return get_tank_elevation(name, tank)

@app.get("/gettankinitlevel/")
def fastapi_get_tank_init_level(name: str, tank: str) -> float | None:
    return get_tank_init_level(name, tank)

@app.get("/gettankminlevel/")
def fastapi_get_tank_min_level(name: str, tank: str) -> float | None:
    return get_tank_min_level(name, tank)

@app.get("/gettankmaxlevel/")
def fastapi_get_tank_max_level(name: str, tank: str) -> float | None:
    return get_tank_max_level(name, tank)

@app.get("/gettankdiameter/")
def fastapi_get_tank_diameter(name: str, tank: str) -> float | None:
    return get_tank_diameter(name, tank)

@app.get("/gettankminvol/")
def fastapi_get_tank_min_vol(name: str, tank: str) -> float | None:
    return get_tank_min_vol(name, tank)

@app.get("/gettankvolcurve/")
def fastapi_get_tank_vol_curve(name: str, tank: str) -> str | None:
    return get_tank_vol_curve(name, tank)

@app.get("/gettankoverflow/")
def fastapi_get_tank_overflow(name: str, tank: str) -> str | None:
    return get_tank_overflow(name, tank)

@app.get("/gettankcoord/")
def fastapi_get_tank_coord(name: str, tank: str) -> dict[str, float] | None:
    return get_tank_coord(name, tank)

@app.post("/settankelevation/")
def fastapi_set_tank_elevation(name: str, tank: str, elevation: float) -> ChangeSet:
    return set_tank_elevation(name, tank, elevation)

@app.post("/settankinitlevel/")
def fastapi_set_tank_init_level(name: str, tank: str, init_level: float) -> ChangeSet:
    return set_tank_init_level(name, tank, init_level)

@app.post("/settankminlevel/")
def fastapi_set_tank_min_level(name: str, tank: str, min_level: float) -> ChangeSet:
    return set_tank_min_level(name, tank, min_level)

@app.post("/settankmaxlevel/")
def fastapi_set_tank_max_level(name: str, tank: str, max_level: float) -> ChangeSet:
    return set_tank_max_level(name, tank, max_level)

@app.post("settankdiameter//")
def fastapi_set_tank_diameter(name: str, tank: str, diameter: float) -> ChangeSet:
    return set_tank_diameter(name, tank, diameter)

@app.post("/settankminvol/")
def fastapi_set_tank_min_vol(name: str, tank: str, min_vol: float) -> ChangeSet:
    return set_tank_min_vol(name, tank, min_vol)

@app.post("/settankvolcurve/")
def fastapi_set_tank_vol_curve(name: str, tank: str, vol_curve: str) -> ChangeSet:
    return set_tank_vol_curve(name, tank, vol_curve)

@app.post("/settankoverflow/")
def fastapi_set_tank_overflow(name: str, tank: str, overflow: str) -> ChangeSet:
    return set_tank_overflow(name, tank, overflow)

@app.post("/settankcoord/")
def fastapi_set_tank_coord(name: str, tank: str, x: float, y: float) -> ChangeSet:
    return set_tank_coord(name, tank, x, y)

############################################################
# pipe 4.[PIPES]
############################################################

@app.post("/addpipe/")
def fastapi_add_pipe(name: str, pipe: str, node1: str, node2: str, length: float = 0, diameter: float = 0, roughness: float = 0, minorloss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
    return add_pipe(name, pipe, node1, node2, length, diameter, roughness, minorloss, status)

@app.post("/deletepipe/")
def fastapi_delete_pipe(name: str, pipe: str) -> ChangeSet:
    return delete_pipe(name, pipe)

@app.get("/getpipenode1/")
def fastapi_get_pipe_node1(name: str, pipe: str) -> str | None:
    return get_pipe_node1(name, pipe)

@app.get("/getpipenode2/")
def fastapi_get_pipe_node2(name: str, pipe: str) -> str | None:
    return get_pipe_node2(name, pipe)

@app.get("/getpipelength/")
def fastapi_get_pipe_length(name: str, pipe: str) -> float | None:
    return get_pipe_length(name, pipe)

@app.get("/getpipediameter/")
def fastapi_get_pipe_diameter(name: str, pipe: str) -> float | None:
    return get_pipe_diameter(name, pipe)

@app.get("/getpiperoughness/")
def fastapi_get_pipe_roughness(name: str, pipe: str) -> float | None:
    return get_pipe_roughness(name, pipe)

@app.get("/getpipeminorloss/")
def fastapi_get_pipe_minor_loss(name: str, pipe: str) -> float | None:
    return get_pipe_minor_loss(name, pipe)

@app.get("/getpipestatus/")
def fastapi_get_pipe_status(name: str, pipe: str) -> str | None:
    return get_pipe_status(name, pipe)

@app.post("/setpipenode1/")
def fastapi_set_pipe_node1(name: str, pipe: str, node1: str) -> ChangeSet:
    return set_pipe_node1(name, pipe, node1)

@app.post("/setpipenode2/")
def fastapi_set_pipe_node2(name: str, pipe: str, node2: str) -> ChangeSet:
    return set_pipe_node2(name, pipe, node2)

@app.post("/setpipelength/")
def fastapi_set_pipe_length(name: str, pipe: str, length: float) -> ChangeSet:
    return set_pipe_length(name, pipe, length)

@app.post("/setpipediameter/")
def fastapi_set_pipe_diameter(name: str, pipe: str, diameter: float) -> ChangeSet:
    return set_pipe_diameter(name, pipe, diameter)

@app.post("/setpiperoughness/")
def fastapi_set_pipe_roughness(name: str, pipe: str, roughness: float) -> ChangeSet:
    return set_pipe_roughness(name, pipe, roughness)

@app.post("/setpipeminorloss/")
def fastapi_set_pipe_minor_loss(name: str, pipe: str, minor_loss: float) -> ChangeSet:
    return set_pipe_minor_loss(name, pipe, minor_loss)

@app.post("/setpipestatus/")
def fastapi_set_pipe_status(name: str, pipe: str, status: float) -> ChangeSet:
    return set_pipe_status(name, pipe, status)


############################################################
# pump 4.[PUMPS]
############################################################

@app.post("/addpump/")
def fastapi_add_pump(name: str, pump: str, node1: str, node2: str) -> ChangeSet:
    return add_pump(name, pump, node1, node2)

@app.post("/deletepump/")
def fastapi_delete_pump(name: str, pump: str) -> ChangeSet:
    return delete_pump(name, pump)

@app.get("/getpumpnode1/")
def fastapi_get_pump_node1(name: str, pump: str) -> str | None:
    return get_pump_node1(name, pump)

@app.get("/getpumpnode2/")
def fastapi_get_pump_node2(name: str, pump: str) -> str | None:
    return get_pump_node2(name, pump)

@app.post("/setpumpnode1/")
def fastapi_set_pump_node1(name: str, pump: str, node1: str) -> ChangeSet:
    return set_pump_node1(name, pump, node1)

@app.post("/setpumpnode2/")
def fastapi_set_pump_node2(name: str, pump: str, node2: str) -> ChangeSet:
    return set_pump_node2(name, pump, node2)


############################################################
# valve 4.[VALVES]
############################################################

@app.post("/addvalve/")
def fastapi_add_valve(name: str, valve: str, node1: str, node2: str, diameter: float = 0, type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
    return add_valve(name, valve, node1, node2, diameter, type, setting, minor_loss)

@app.post("/deletevalve/")
def fastapi_delete_valve(name: str, valve: str) -> ChangeSet:
    return delete_valve(name, valve)

@app.get("/getvalvenode1/")
def fastapi_get_valve_node1(name: str, valve: str) -> str | None:
    return get_valve_node1(name, valve)

@app.get("/getvalvenode2/")
def fastapi_get_valve_node2(name: str, valve: str) -> str | None:
    return get_valve_node2(name, valve)

@app.get("/getvalvediameter/")
def fastapi_get_valve_diameter(name: str, valve: str) -> float | None:
    return get_valve_diameter(name, valve)

@app.get("/getvalvetype/")
def fastapi_get_valve_type(name: str, valve: str) -> str | None:
    return get_valve_type(name, valve)

@app.get("/getvalvesetting/")
def fastapi_get_valve_setting(name: str, valve: str) -> float | None:
    return get_valve_setting(name, valve)

@app.get("/getvalveminorloss/")
def fastapi_get_valve_minor_loss(name: str, valve: str) -> float | None:
    return get_valve_minor_loss(name, valve)

@app.post("/setvalvenode1/")
def fastapi_set_valve_node1(name: str, valve: str, node1: str) -> ChangeSet:
    return set_valve_node1(name, valve, node1)

@app.post("/setvalvenode2/")
def fastapi_set_valve_node2(name: str, valve: str, node2: str) -> ChangeSet:
    return set_valve_node2(name, valve, node2)

@app.post("/setvalvenodediameter/")
def fastapi_set_valve_diameter(name: str, valve: str, diameter: float) -> ChangeSet:
    return set_valve_diameter(name, valve, diameter)

@app.post("/setvalvetype/")
def fastapi_set_valve_type(name: str, valve: str, type: str) -> ChangeSet:
    return set_valve_type(name, valve, type)

@app.post("/setvalvesetting/")
def fastapi_set_valve_setting(name: str, valve: str, setting: float) -> ChangeSet:
    return set_valve_setting(name, valve, setting)



# inp file
@app.post("/uploadinp/", status_code=status.HTTP_200_OK)
async def upload_inp(file: bytes = File(), name: str = None):
    filePath = inpDir + str(name)
    f = open(filePath, 'wb')
    f.write(file)
    f.close()

    return True

@app.get("/downloadinp/", status_code=status.HTTP_200_OK)
async def download_inp(name: str, response: Response):
    filePath = inpDir + name 
    if os.path.exists(filePath):
        return FileResponse(filePath, media_type='application/octet-stream', filename="inp.inp")
    else:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return True
    
@app.get("/getjson/")
async def get_json():
    return JSONResponse(
        status_code = status.HTTP_400_BAD_REQUEST,
        content={
            'code': 400,
            'message': "this is message",
            'data': 123,
        }
    )