# -*- coding: mbcs -*-
# Do not delete the following import lines
from abaqus import *
from abaqusConstants import *
import __main__
from abaqus import getInput
from math import sqrt

import section
import regionToolset
import displayGroupMdbToolset as dgm
import part
import material
import assembly
import step
import interaction
import load
import mesh
import optimization
import job
import sketch
import visualization
import xyPlot
import displayGroupOdbToolset as dgo
import connectorBehavior
import random
import math
import time
import sys
import getopt


# Werte initialisieren

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y


class Canvas:

    def __init__(self, a, b, FVC, radius   ):
        self.a = a
        self.b = b
        self.FVC = FVC
        self.radius = radius

    def isInCanvas(self, circle):
        if circle.center.x <= (self.a / 2 - circle.radius) and circle.center.x >= -(
                self.a / 2 - circle.radius) and circle.center.y <= (
                self.b / 2 - circle.radius) and circle.center.y >= -(self.b / 2 - circle.radius):
            return True
        return False


class Circle:

    def __init__(self, center, radius):
        self.center = center
        self.radius = radius

    def isIntersected(self, circle):
        if self == circle:
            return False
            print("gleicher Kreis getestet")
        dist = math.sqrt((self.center.x - circle.center.x) * (self.center.x - circle.center.x) + (
                    self.center.y - circle.center.y) * (self.center.y - circle.center.y))
        # berechnet den Abstand des übergebenen Punkts zu sich selbst

        if dist < (self.radius + circle.radius):
            return True


def isIntersectedWithList(circleList, circle):
    # überprüft, ob sich der Kreis mit anderen Kreisen überschneidet. Kriterium: Mittelpunkte müssen eine Distanz > 2*RADIUS aufweisen
    for a in range(0, len(circleList)):
        # print ("a:   " , a, " von ", len(CenterX))

        if circle.isIntersected(circleList[a]):
            print(circle, " is intersected with ", circleList[a])
            # HIER LIEGT der Fehler! Die Kreise überschneiden sich mit sich selbst!
            return True
    return False


def drawCircle(myname, circle):
    p = mdb.models['Model-1'].parts['Part-1']
    f, e, d1 = p.faces, p.edges, p.datums
    t = p.MakeSketchTransform(sketchPlane=f[0], sketchPlaneSide=SIDE1, origin=(
        0, 0, 0.0))
    s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',
                                                sheetSize=70.71, gridSpacing=1.76, transform=t)
    g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints
    s.setPrimaryObject(option=SUPERIMPOSE)
    p = mdb.models['Model-1'].parts['Part-1']
    p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)

    for i in range(0, len(circleList)):
        name = ("Fiber " + str(i))
        x1 = circleList[i].center.x
        y1 = circleList[i].center.y
        r1 = circleList[i].radius
        s.CircleByCenterPerimeter(center=(x1, y1), point1=(x1 + r1 - 1, y1))
        s.CircleByCenterPerimeter(center=(x1, y1), point1=(x1 + r1, y1))
    print ("Punkt ", " mit X =", x1, "y= ", y1, "erstellt")

    p = mdb.models['Model-1'].parts['Part-1']
    f = p.faces
    pickedFaces = f.getSequenceFromMask(mask=('[#1 ]',), )
    e1, d2 = p.edges, p.datums
    p.PartitionFaceBySketch(faces=pickedFaces, sketch=s)
    s.unsetPrimaryObject()
    del mdb.models['Model-1'].sketches['__profile__']



def drawCanvas(myCanvas):

    print("Canvas mit Eckpunkten P1 = ", -myCanvas.a/2,-myCanvas.b/2, "P2 =", myCanvas.a/2,myCanvas.b/2," erstellt")

    s1 = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',
        sheetSize=200.0)
    g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints
    s1.setPrimaryObject(option=STANDALONE)
    s1.rectangle(point1=(-myCanvas.a/2,-myCanvas.b/2), point2=(myCanvas.a/2,myCanvas.b/2))
    p = mdb.models['Model-1'].Part(name='Part-1', dimensionality=TWO_D_PLANAR,
        type=DEFORMABLE_BODY)
    p = mdb.models['Model-1'].parts['Part-1']
    p.BaseShell(sketch=s1)
    s1.unsetPrimaryObject()
    p = mdb.models['Model-1'].parts['Part-1']
    session.viewports['Viewport: 1'].setValues(displayedObject=p)
    del mdb.models['Model-1'].sketches['__profile__']


def DrawRectangleInclusion():
    p = mdb.models['Model-1'].parts['Part-1']
    f1, e1, d2 = p.faces, p.edges, p.datums
    t = p.MakeSketchTransform(sketchPlane=f1.findAt(coordinates=(-11.666667,
                                                                 -11.666667, 0.0), normal=(0.0, 0.0, 1.0)),
                              sketchPlaneSide=SIDE1,
                              origin=(0.0, 0.0, 0.0))
    s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',
                                                sheetSize=197.98, gridSpacing=4.94, transform=t)
    g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints
    s.setPrimaryObject(option=SUPERIMPOSE)
    p = mdb.models['Model-1'].parts['Part-1']
    p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)
    s.rectangle(point1=(0.0, 0.0), point2=(35.0, 35.0))
    p = mdb.models['Model-1'].parts['Part-1']
    f = p.faces
    pickedFaces = f.findAt(((-11.666667, -11.666667, 0.0),))
    e, d1 = p.edges, p.datums
    p.PartitionFaceBySketch(faces=pickedFaces, sketch=s)
    s.unsetPrimaryObject()
    del mdb.models['Model-1'].sketches['__profile__']


def MakeSet(circleList):

    p = mdb.models['Model-1'].parts['Part-1']
    f = p.faces

    list_x = (1,-1,0)
    list_y = (1,-1,0)

    coordinates_for_faces = tuple()
    tuple_coordinates = tuple()

    for i in range(0,2):
        tuple_coordinates = ((list_x[i], list_y[i], 0.0),)
        coordinates_for_faces = coordinates_for_faces + tuple_coordinates

    print("coordinates_for_faces", coordinates_for_faces)
    faces = f.findAt(coordinates_for_faces)
    p.Set(faces=faces, name='SetOfFibers')


def generatePointByPhi(circleList):
    d = random.uniform(RADIUS, 28)
    # Grenzen von d sollten sich dem Radius und dem Faservolumengehalt anpassen. Obere Grenze sollte 2 * RADIUS + mittler Abstand bei geg. Faservolumengehalt entsprechen
    # d sollte mit tries größer werden, damit sich der Algorithmus nicht in einer Ecke frisst
    phi = random.uniform(0, 360)
    i = len(circleList)
    return Point(circleList[i].center.x + d * math.cos(phi), circleList[i].center.y + d * math.sin(phi))

def generatePointByRandomCoordinates(myCanvas):
    x = random.uniform(-myCanvas.a/2+myCanvas.radius, myCanvas.a/2-myCanvas.radius)
    y = random.uniform(-myCanvas.b/2+myCanvas.radius, myCanvas.b/2-myCanvas.radius)
    return Point(x,y)

def verdichten(myCanvas, circleList, xtimes):
    for i in range(0,xtimes):
        for i in range(0, len(circleList)):
            print ("Durchlauf verdichten, Objekt", i, "von ", len(circleList))
            print ("Y vorher: ", circleList[i].center.y)
            # im Folgenden wird nach unten verdichtet
            if circleList[i].center.y-1 > -(myCanvas.b/2 - circleList[i].radius):
                circleList[i].center.y -= 1
                print("nach unten verdichtet")

                if isIntersectedWithList(circleList,circleList[i]):
                    circleList[i].center.y += 1
                    #print("is intersected")

            print("Y nachher: ", circleList[i].center.y)

            # im Folgenden wird nach links verdichtet
            if circleList[i].center.x -1 > -(myCanvas.a/2 - circleList[i].radius):
                circleList[i].center.x -= 1
                #print(circleList[i], " nach links verdichtet", circleList[i].center.y -1, -(myCanvas.b/2 - circleList[i].radius))
                if isIntersectedWithList(circleList, circleList[i]):
                    circleList[i].center.x += 1
                    print("is intersected")



def main():
    RADIUS = 3.5
    desiredFVC = float(getInput('Desired Fiber-Volume-Content: (p.ex. 0.40)'))
    print("desired FVC", desiredFVC, "#################################################")
    FVC = 0

    myCanvas = Canvas(70, 70, desiredFVC, RADIUS )
    circleList = []

    tries = 0
    while FVC < desiredFVC:
        tries += 1
        print("Versuche: ", tries)

        if tries > 10000:
            break
        if tries == 5000:
            verdichten(myCanvas,circleList,5)
        if tries == 6000:
            verdichten(myCanvas,circleList,5)

        i = len(circleList) - 1

        #candidatePoint = generatePointByPhi(circleList)
        # StartPoint = Point(0, 0)
        # StartCircle = Circle(StartPoint, RADIUS)
        # circleList.append(StartCircle)
        candidatePoint = generatePointByRandomCoordinates(myCanvas)
        candidateCircle = Circle(candidatePoint, RADIUS)

        if not myCanvas.isInCanvas(candidateCircle):
            print ("not in canvas")
            continue

        if isIntersectedWithList(circleList, candidateCircle):
            print ("intersected with list")
            continue

        circleList.append(candidateCircle)
        tries = 0
        FVC = (len(circleList) * math.pi * RADIUS * RADIUS) / (myCanvas.a * myCanvas.b)
        print("FVC: ", FVC)

    drawCanvas(myCanvas)
    #drawCircles(circleList)
    DrawRectangleInclusion()
    MakeSet(circleList)

if (__name__ == "__main__"):
    main()