updated responsemessages to evaluate own prior responses to new selected responses based on the client

ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java

@@ -55,8 +55,12 @@ public class Datahandler {
     public static final long EXPIRE_TIME_IN_SECONDS1 = TimeUnit.SECONDS.convert(10, TimeUnit.HOURS);
     public static Datahandler instance = new Datahandler();
     private static volatile Double minDistance;
+    private static Annotation strAnno;
+    private static Annotation strAnnoSentiment;
+    private static Annotation strAnnoJMWE;
     private volatile boolean refreshMatrixFromDB;
     private static volatile int secondaryIterator = 0;
+    private static volatile Double preRelationCounters = 0.0;
     private final ConcurrentMap<Integer, String> stringCache;
     private static ConcurrentMap<String, Annotation> pipelineAnnotationCache;
     private static ConcurrentMap<String, Annotation> pipelineSentimentAnnotationCache;
@@ -395,7 +399,7 @@ public class Datahandler {
         }
     }
 
-    public synchronized String getResponseMsg(String str) throws CustomError {
+    public synchronized String getResponseMsg(String str, String MostRecent) throws CustomError {
         str = str.trim();
         if (str.startsWith("<@")) {
             str = str.substring(str.indexOf("> ") + 2);
@@ -405,7 +409,7 @@ public class Datahandler {
         double Score = -10000;
         SimilarityMatrix SMXreturn = new SimilarityMatrix("", "");
         System.out.println("pre mostSimilarSTR \n");
-        String mostSimilarSTR = mostSimilar(str, strArrs);
+        String mostSimilarSTR = mostSimilar(str, strArrs, MostRecent);
         if (mostSimilarSTR != null) {
             LinkedHashMap<String, Double> orDefault = LHMSMXLocal.getOrDefault(mostSimilarSTR, null);
             if (orDefault != null) {
@@ -438,24 +442,17 @@ public class Datahandler {
             }
         }
         System.out.println("none within 8 range");
-        Annotation strAnno = new Annotation(str);
-        pipeline.annotate(strAnno);
-        Annotation strAnno2 = new Annotation(str);
-        pipelineSentiment.annotate(strAnno2);
-        List<String> notactualList = new ArrayList();
-        notactualList.add(str);
-        ConcurrentMap<String, Annotation> jmweAnnotation = PipelineJMWESingleton.INSTANCE.getJMWEAnnotation(notactualList);
-        final Annotation strAnno3 = jmweAnnotation.values().iterator().next();
         ConcurrentMap<Integer, String> strCache = stringCache;
         ConcurrentMap<Integer, Future<SimilarityMatrix>> futureslocal = new MapMaker().concurrencyLevel(2).makeMap();
         ConcurrentMap<Integer, SimilarityMatrix> futurereturn = new MapMaker().concurrencyLevel(2).makeMap();
         String strF = str;
+        getSingularAnnotation(strF);
         strCache.values().parallelStream().forEach((str1) -> {
             if (!strF.equals(str1)) {
                 SimilarityMatrix SMX = new SimilarityMatrix(strF, str1);
                 Callable<SimilarityMatrix> worker = new SentimentAnalyzerTest(strF, str1, SMX,
-                        strAnno3, jmweAnnotationCache.get(str1), strAnno,
+                        strAnnoJMWE, jmweAnnotationCache.get(str1), strAnno,
-                        pipelineAnnotationCache.get(str1), strAnno2,
+                        pipelineAnnotationCache.get(str1), strAnnoSentiment,
                         pipelineSentimentAnnotationCache.get(str1));
                 futureslocal.put(futureslocal.size() + 1, executor.submit(worker));
             }
@@ -463,13 +460,50 @@ public class Datahandler {
         futureslocal.values().parallelStream().forEach((future) -> {
             SimilarityMatrix SMX = new SimilarityMatrix("", "");
             try {
-                SMX = future.get(20, TimeUnit.SECONDS);
+                SMX = future.get(5, TimeUnit.SECONDS);
                 futurereturn.put(futurereturn.size() + 1, SMX);
             } catch (InterruptedException | ExecutionException | TimeoutException ex) {
                 System.out.println("ex getResponsemsg: " + ex.getMessage() + "\n");
             }
         });
+        ConcurrentMap<Integer, SimilarityMatrix> smxUpdateReturn = new MapMaker().concurrencyLevel(2).makeMap();
         for (SimilarityMatrix SMX : futurereturn.values()) {
+            Double scoreRelation = 500.0;
+            boolean foundmatch = false;
+            if (!MostRecent.isEmpty()) {
+                LinkedHashMap<String, Double> orDefault1 = lHMSMX.getOrDefault(MostRecent, null);
+                if (orDefault1 != null) {
+                    Collection<String> orDefaultstrs = orDefault1.keySet();
+                    for (String strs : orDefaultstrs) {
+                        if (strs.equals(SMX.getSecondaryString())) {
+                            scoreRelation = orDefault1.get(SMX.getSecondaryString());
+                            foundmatch = true;
+                            break;
+                        }
+                    }
+                }
+                if (!foundmatch) {
+                    orDefault1 = lHMSMX.getOrDefault(SMX.getSecondaryString(), null);
+                    if (orDefault1 != null) {
+                        Collection<String> orDefaultstrs = orDefault1.keySet();
+                        for (String strs : orDefaultstrs) {
+                            if (strs.equals(MostRecent)) {
+                                scoreRelation = orDefault1.get(MostRecent);
+                                foundmatch = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!foundmatch) {
+                scoreRelation = getScoreRelationNewMsgToRecentMsg(SMX.getSecondaryString(), MostRecent);
+            }
+            if (scoreRelation > 500.0 + (25 * smxUpdateReturn.size())) {
+                smxUpdateReturn.put(smxUpdateReturn.size() + 1, SMX);
+            }
+        }
+        for (SimilarityMatrix SMX : smxUpdateReturn.values()) {
             double distance = SMX.getDistance();
             if (distance > Score) {
                 Score = distance;
@@ -481,31 +515,103 @@ public class Datahandler {
         return SMXreturn.getSecondaryString();
     }
 
-    public String mostSimilar(String toBeCompared, ConcurrentMap<Integer, String> concurrentStrings) {
+    public void getSingularAnnotation(String str) {
+        strAnno = new Annotation(str);
+        pipeline.annotate(strAnno);
+        strAnnoSentiment = new Annotation(str);
+        pipelineSentiment.annotate(strAnnoSentiment);
+        List<String> notactualList = new ArrayList();
+        notactualList.add(str);
+        ConcurrentMap<String, Annotation> jmweAnnotation = PipelineJMWESingleton.INSTANCE.getJMWEAnnotation(notactualList);
+        strAnnoJMWE = jmweAnnotation.values().iterator().next();
+    }
+
+    private Double getScoreRelationNewMsgToRecentMsg(String str, String mostRecentMsg) {
+        SimilarityMatrix SMX = new SimilarityMatrix(str, mostRecentMsg);
+        Callable<SimilarityMatrix> worker = new SentimentAnalyzerTest(str, mostRecentMsg, SMX,
+                jmweAnnotationCache.get(str), jmweAnnotationCache.get(mostRecentMsg), pipelineAnnotationCache.get(str),
+                pipelineAnnotationCache.get(mostRecentMsg), pipelineSentimentAnnotationCache.get(str),
+                pipelineSentimentAnnotationCache.get(mostRecentMsg));
+        SimilarityMatrix callSMX = null;
+        try {
+            callSMX = worker.call();
+        } catch (Exception ex) {
+            Logger.getLogger(Datahandler.class
+                    .getName()).log(Level.SEVERE, null, ex);
+        }
+        if (callSMX != null) {
+            double smxDistance = callSMX.getDistance();
+            return smxDistance;
+        }
+        return 0.0;
+    }
+
+    public String mostSimilar(String toBeCompared, ConcurrentMap<Integer, String> concurrentStrings, String MostRecent) {
         similar = "";
-        minDistance = 12.5;
+        minDistance = 7.0;
+        preRelationCounters = 500.0;
+        ConcurrentMap<Integer, String> similardistances = new MapMaker().concurrencyLevel(2).makeMap();
         concurrentStrings.values().parallelStream().forEach((str) -> {
             LevenshteinDistance leven = new LevenshteinDistance(toBeCompared, str);
             double distance = leven.computeLevenshteinDistance();
-            if (distance < minDistance) {
+            if (distance <= minDistance) {
                 minDistance = distance;
                 System.out.println("distance: " + distance + "\n");
-                similar = str;
+                similardistances.put(similardistances.size() + 1, str);
             }
         });
-        LinkedHashMap<String, Double> orDefault = lHMSMX.getOrDefault(similar, null);
+        if (similardistances.isEmpty()) {
-        if (orDefault == null) {
             return null;
         }
         Double maxDistance = 0.0;
+        for (String str : similardistances.values()) {
+            LinkedHashMap<String, Double> orDefault = lHMSMX.getOrDefault(str, null);
+            if (orDefault != null) {
                 for (Entry<String, Double> defaultEntry : orDefault.entrySet()) {
                     Double value = defaultEntry.getValue();
+                    String key = defaultEntry.getKey();
                     if (value > maxDistance) {
+                        Double RelationScore = 500.0;
+                        boolean foundmatch = false;
+                        if (!MostRecent.isEmpty()) {
+                            LinkedHashMap<String, Double> orDefault1 = lHMSMX.getOrDefault(MostRecent, null);
+                            if (orDefault1 != null) {
+                                Collection<String> orDefaultstrs = orDefault1.keySet();
+                                for (String strs : orDefaultstrs) {
+                                    if (strs.equals(key)) {
+                                        RelationScore = orDefault1.get(key);
+                                        foundmatch = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!foundmatch) {
+                                orDefault1 = lHMSMX.getOrDefault(key, null);
+                                if (orDefault1 != null) {
+                                    Collection<String> orDefaultstrs = orDefault1.keySet();
+                                    for (String strs : orDefaultstrs) {
+                                        if (strs.equals(MostRecent)) {
+                                            RelationScore = orDefault1.get(MostRecent);
+                                            foundmatch = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if (!foundmatch) {
+                            RelationScore = getScoreRelationNewMsgToRecentMsg(key, MostRecent);
+                        }
+                        if (RelationScore > preRelationCounters) {
                             maxDistance = value;
                             similar = defaultEntry.getKey();
+                            preRelationCounters = RelationScore;
                         }
                     }
-        return similar;
+                }
+            }
+        }
+        return similar.isEmpty() ? null : similar;
     }
 
     public static ConcurrentMap<Integer, String> cutContent(ConcurrentMap<Integer, String> str, boolean hlStatsMsg) {
@@ -729,4 +835,5 @@ public class Datahandler {
         });
         return strmap;
     }
+
 }

ArtificialAutism/src/main/java/FunctionLayer/MessageResponseHandler.java

@@ -39,7 +39,7 @@ public class MessageResponseHandler {
         }
     }
     
-    public static String selectReponseMessage(String toString) throws CustomError {
+    public synchronized static String selectReponseMessage(String toString, String mostRecentMsg) throws CustomError {
         ConcurrentMap<Integer, String> str1 = new MapMaker().concurrencyLevel(2).makeMap();
         str1.put(str1.size() + 1, toString);
         str1 = Datahandler.cutContent(str1, false);
@@ -49,7 +49,7 @@ public class MessageResponseHandler {
                 strreturn = str;
             }
         }
-        String getResponseMsg = Datahandler.instance.getResponseMsg(strreturn);
+        String getResponseMsg = Datahandler.instance.getResponseMsg(strreturn, mostRecentMsg);
         return getResponseMsg;
     }
 }

ArtificialAutism/src/main/java/PresentationLayer/DiscordHandler.java

@@ -33,6 +33,8 @@ import org.javacord.api.entity.user.User;
  */
 public class DiscordHandler {
 
+    private static String MostRecentMsg = "initial state";
+
     public static void main(String[] args) {
         System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "25");
         try {
@@ -92,10 +94,11 @@ public class DiscordHandler {
                         || event.getServerTextChannel().get().toString().contains("general-autism")) {
                     String ResponseStr;
                     try {
-                        ResponseStr = MessageResponseHandler.selectReponseMessage(event.getMessage().toString());
+                        ResponseStr = MessageResponseHandler.selectReponseMessage(event.getMessage().toString(), MostRecentMsg);
                         if (!ResponseStr.isEmpty()) {
                             System.out.print("\nResponseStr3: " + ResponseStr + "\n");
                             event.getChannel().sendMessage(ResponseStr);
+                            MostRecentMsg = ResponseStr;
                         }
                         new Thread(() -> {
                             try {