src/be/nikiroo/fanfix/supported/BasicSupport.java

   1 package be.nikiroo.fanfix.supported;
   2
   3 import java.awt.image.BufferedImage;
   4 import java.io.BufferedReader;
   5 import java.io.ByteArrayInputStream;
   6 import java.io.File;
   7 import java.io.IOException;
   8 import java.io.InputStream;
   9 import java.io.InputStreamReader;
  10 import java.net.MalformedURLException;
  11 import java.net.URL;
  12 import java.util.ArrayList;
  13 import java.util.Date;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18 import java.util.Scanner;
  19
  20 import be.nikiroo.fanfix.Instance;
  21 import be.nikiroo.fanfix.bundles.Config;
  22 import be.nikiroo.fanfix.bundles.StringId;
  23 import be.nikiroo.fanfix.data.Chapter;
  24 import be.nikiroo.fanfix.data.MetaData;
  25 import be.nikiroo.fanfix.data.Paragraph;
  26 import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
  27 import be.nikiroo.fanfix.data.Story;
  28 import be.nikiroo.utils.ImageUtils;
  29 import be.nikiroo.utils.Progress;
  30 import be.nikiroo.utils.StringUtils;
  31
  32 /**
  33  * This class is the base class used by the other support classes. It can be
  34  * used outside of this package, and have static method that you can use to get
  35  * access to the correct support class.
  36  * <p>
  37  * It will be used with 'resources' (usually web pages or files).
  38  *
  39  * @author niki
  40  */
  41 public abstract class BasicSupport {
  42         /**
  43          * The supported input types for which we can get a {@link BasicSupport}
  44          * object.
  45          *
  46          * @author niki
  47          */
  48         public enum SupportType {
  49                 /** EPUB files created with this program */
  50                 EPUB,
  51                 /** Pure text file with some rules */
  52                 TEXT,
  53                 /** TEXT but with associated .info file */
  54                 INFO_TEXT,
  55                 /** My Little Pony fanfictions */
  56                 FIMFICTION,
  57                 /** Fanfictions from a lot of different universes */
  58                 FANFICTION,
  59                 /** Website with lots of Mangas */
  60                 MANGAFOX,
  61                 /** Furry website with comics support */
  62                 E621,
  63                 /** Furry website with stories */
  64                 YIFFSTAR,
  65                 /** Comics and images groups, mostly but not only NSFW */
  66                 E_HENTAI,
  67                 /** CBZ files */
  68                 CBZ,
  69                 /** HTML files */
  70                 HTML;
  71
  72                 /**
  73                  * A description of this support type (more information than the
  74                  * {@link BasicSupport#getSourceName()}).
  75                  *
  76                  * @return the description
  77                  */
  78                 public String getDesc() {
  79                         String desc = Instance.getTrans().getStringX(StringId.INPUT_DESC,
  80                                         this.name());
  81
  82                         if (desc == null) {
  83                                 desc = Instance.getTrans().getString(StringId.INPUT_DESC, this);
  84                         }
  85
  86                         return desc;
  87                 }
  88
  89                 /**
  90                  * The name of this support type (a short version).
  91                  *
  92                  * @return the name
  93                  */
  94                 public String getSourceName() {
  95                         BasicSupport support = BasicSupport.getSupport(this);
  96                         if (support != null) {
  97                                 return support.getSourceName();
  98                         }
  99
 100                         return null;
 101                 }
 102
 103                 @Override
 104                 public String toString() {
 105                         return super.toString().toLowerCase();
 106                 }
 107
 108                 /**
 109                  * Call {@link SupportType#valueOf(String)} after conversion to upper
 110                  * case.
 111                  *
 112                  * @param typeName
 113                  *            the possible type name
 114                  *
 115                  * @return NULL or the type
 116                  */
 117                 public static SupportType valueOfUC(String typeName) {
 118                         return SupportType.valueOf(typeName == null ? null : typeName
 119                                         .toUpperCase());
 120                 }
 121
 122                 /**
 123                  * Call {@link SupportType#valueOf(String)} after conversion to upper
 124                  * case but return NULL for NULL instead of raising exception.
 125                  *
 126                  * @param typeName
 127                  *            the possible type name
 128                  *
 129                  * @return NULL or the type
 130                  */
 131                 public static SupportType valueOfNullOkUC(String typeName) {
 132                         if (typeName == null) {
 133                                 return null;
 134                         }
 135
 136                         return SupportType.valueOfUC(typeName);
 137                 }
 138
 139                 /**
 140                  * Call {@link SupportType#valueOf(String)} after conversion to upper
 141                  * case but return NULL in case of error instead of raising an
 142                  * exception.
 143                  *
 144                  * @param typeName
 145                  *            the possible type name
 146                  *
 147                  * @return NULL or the type
 148                  */
 149                 public static SupportType valueOfAllOkUC(String typeName) {
 150                         try {
 151                                 return SupportType.valueOfUC(typeName);
 152                         } catch (Exception e) {
 153                                 return null;
 154                         }
 155                 }
 156         }
 157
 158         private InputStream in;
 159         private SupportType type;
 160         private URL currentReferer; // with only one 'r', as in 'HTTP'...
 161
 162         // quote chars
 163         private char openQuote = Instance.getTrans().getCharacter(
 164                         StringId.OPEN_SINGLE_QUOTE);
 165         private char closeQuote = Instance.getTrans().getCharacter(
 166                         StringId.CLOSE_SINGLE_QUOTE);
 167         private char openDoubleQuote = Instance.getTrans().getCharacter(
 168                         StringId.OPEN_DOUBLE_QUOTE);
 169         private char closeDoubleQuote = Instance.getTrans().getCharacter(
 170                         StringId.CLOSE_DOUBLE_QUOTE);
 171
 172         /**
 173          * The name of this support class.
 174          *
 175          * @return the name
 176          */
 177         protected abstract String getSourceName();
 178
 179         /**
 180          * Check if the given resource is supported by this {@link BasicSupport}.
 181          *
 182          * @param url
 183          *            the resource to check for
 184          *
 185          * @return TRUE if it is
 186          */
 187         protected abstract boolean supports(URL url);
 188
 189         /**
 190          * Return TRUE if the support will return HTML encoded content values for
 191          * the chapters content.
 192          *
 193          * @return TRUE for HTML
 194          */
 195         protected abstract boolean isHtml();
 196
 197         /**
 198          * Return the {@link MetaData} of this story.
 199          *
 200          * @param source
 201          *            the source of the story
 202          * @param in
 203          *            the input (the main resource)
 204          *
 205          * @return the associated {@link MetaData}
 206          *
 207          * @throws IOException
 208          *             in case of I/O error
 209          */
 210         protected abstract MetaData getMeta(URL source, InputStream in)
 211                         throws IOException;
 212
 213         /**
 214          * Return the story description.
 215          *
 216          * @param source
 217          *            the source of the story
 218          * @param in
 219          *            the input (the main resource)
 220          *
 221          * @return the description
 222          *
 223          * @throws IOException
 224          *             in case of I/O error
 225          */
 226         protected abstract String getDesc(URL source, InputStream in)
 227                         throws IOException;
 228
 229         /**
 230          * Return the list of chapters (name and resource).
 231          *
 232          * @param source
 233          *            the source of the story
 234          * @param in
 235          *            the input (the main resource)
 236          * @param pg
 237          *            the optional progress reporter
 238          *
 239          * @return the chapters
 240          *
 241          * @throws IOException
 242          *             in case of I/O error
 243          */
 244         protected abstract List<Entry<String, URL>> getChapters(URL source,
 245                         InputStream in, Progress pg) throws IOException;
 246
 247         /**
 248          * Return the content of the chapter (possibly HTML encoded, if
 249          * {@link BasicSupport#isHtml()} is TRUE).
 250          *
 251          * @param source
 252          *            the source of the story
 253          * @param in
 254          *            the input (the main resource)
 255          * @param number
 256          *            the chapter number
 257          * @param pg
 258          *            the optional progress reporter
 259          *
 260          * @return the content
 261          *
 262          * @throws IOException
 263          *             in case of I/O error
 264          */
 265         protected abstract String getChapterContent(URL source, InputStream in,
 266                         int number, Progress pg) throws IOException;
 267
 268         /**
 269          * Log into the support (can be a no-op depending upon the support).
 270          *
 271          * @throws IOException
 272          *             in case of I/O error
 273          */
 274         @SuppressWarnings("unused")
 275         public void login() throws IOException {
 276         }
 277
 278         /**
 279          * Return the list of cookies (values included) that must be used to
 280          * correctly fetch the resources.
 281          * <p>
 282          * You are expected to call the super method implementation if you override
 283          * it.
 284          *
 285          * @return the cookies
 286          */
 287         public Map<String, String> getCookies() {
 288                 return new HashMap<String, String>();
 289         }
 290
 291         /**
 292          * OAuth authorisation (aka, "bearer XXXXXXX").
 293          *
 294          * @return the OAuth string
 295          */
 296         public String getOAuth() {
 297                 return null;
 298         }
 299
 300         /**
 301          * Return the canonical form of the main {@link URL}.
 302          *
 303          * @param source
 304          *            the source {@link URL}
 305          *
 306          * @return the canonical form of this {@link URL}
 307          *
 308          * @throws IOException
 309          *             in case of I/O error
 310          */
 311         @SuppressWarnings("unused")
 312         public URL getCanonicalUrl(URL source) throws IOException {
 313                 return source;
 314         }
 315
 316         /**
 317          * Process the given story resource into a partially filled {@link Story}
 318          * object containing the name and metadata, except for the description.
 319          *
 320          * @param url
 321          *            the story resource
 322          *
 323          * @return the {@link Story}
 324          *
 325          * @throws IOException
 326          *             in case of I/O error
 327          */
 328         public Story processMeta(URL url) throws IOException {
 329                 return processMeta(url, true, false, null);
 330         }
 331
 332         /**
 333          * Process the given story resource into a partially filled {@link Story}
 334          * object containing the name and metadata.
 335          *
 336          * @param url
 337          *            the story resource
 338          * @param close
 339          *            close "this" and "in" when done
 340          * @param getDesc
 341          *            retrieve the description of the story, or not
 342          * @param pg
 343          *            the optional progress reporter
 344          *
 345          * @return the {@link Story}
 346          *
 347          * @throws IOException
 348          *             in case of I/O error
 349          */
 350         protected Story processMeta(URL url, boolean close, boolean getDesc,
 351                         Progress pg) throws IOException {
 352                 if (pg == null) {
 353                         pg = new Progress();
 354                 } else {
 355                         pg.setMinMax(0, 100);
 356                 }
 357
 358                 login();
 359                 pg.setProgress(10);
 360
 361                 url = getCanonicalUrl(url);
 362
 363                 setCurrentReferer(url);
 364
 365                 in = openInput(url); // NULL allowed here
 366                 try {
 367                         preprocess(url, getInput());
 368                         pg.setProgress(30);
 369
 370                         Story story = new Story();
 371                         MetaData meta = getMeta(url, getInput());
 372                         if (meta.getCreationDate() == null
 373                                         || meta.getCreationDate().isEmpty()) {
 374                                 meta.setCreationDate(StringUtils.fromTime(new Date().getTime()));
 375                         }
 376                         story.setMeta(meta);
 377
 378                         pg.setProgress(50);
 379
 380                         if (meta.getCover() == null) {
 381                                 meta.setCover(getDefaultCover(meta.getSubject()));
 382                         }
 383
 384                         pg.setProgress(60);
 385
 386                         if (getDesc) {
 387                                 String descChapterName = Instance.getTrans().getString(
 388                                                 StringId.DESCRIPTION);
 389                                 story.getMeta().setResume(
 390                                                 makeChapter(url, 0, descChapterName,
 391                                                                 getDesc(url, getInput()), null));
 392                         }
 393
 394                         pg.setProgress(100);
 395                         return story;
 396                 } finally {
 397                         if (close) {
 398                                 try {
 399                                         close();
 400                                 } catch (IOException e) {
 401                                         Instance.getTraceHandler().error(e);
 402                                 }
 403
 404                                 if (in != null) {
 405                                         in.close();
 406                                 }
 407                         }
 408
 409                         setCurrentReferer(null);
 410                 }
 411         }
 412
 413         /**
 414          * Process the given story resource into a fully filled {@link Story}
 415          * object.
 416          *
 417          * @param url
 418          *            the story resource
 419          * @param pg
 420          *            the optional progress reporter
 421          *
 422          * @return the {@link Story}
 423          *
 424          * @throws IOException
 425          *             in case of I/O error
 426          */
 427         public Story process(URL url, Progress pg) throws IOException {
 428                 if (pg == null) {
 429                         pg = new Progress();
 430                 } else {
 431                         pg.setMinMax(0, 100);
 432                 }
 433
 434                 url = getCanonicalUrl(url);
 435                 pg.setProgress(1);
 436                 try {
 437                         Progress pgMeta = new Progress();
 438                         pg.addProgress(pgMeta, 10);
 439                         Story story = processMeta(url, false, true, pgMeta);
 440                         if (!pgMeta.isDone()) {
 441                                 pgMeta.setProgress(pgMeta.getMax()); // 10%
 442                         }
 443
 444                         if (story == null) {
 445                                 pg.setProgress(90);
 446                                 return null;
 447                         }
 448
 449                         pg.setName("Retrieving " + story.getMeta().getTitle());
 450
 451                         setCurrentReferer(url);
 452
 453                         Progress pgGetChapters = new Progress();
 454                         pg.addProgress(pgGetChapters, 10);
 455                         story.setChapters(new ArrayList<Chapter>());
 456                         List<Entry<String, URL>> chapters = getChapters(url, getInput(),
 457                                         pgGetChapters);
 458                         if (!pgGetChapters.isDone()) {
 459                                 pgGetChapters.setProgress(pgGetChapters.getMax()); // 20%
 460                         }
 461
 462                         if (chapters != null) {
 463                                 Progress pgChaps = new Progress("Extracting chapters", 0,
 464                                                 chapters.size() * 300);
 465                                 pg.addProgress(pgChaps, 80);
 466
 467                                 long words = 0;
 468                                 int i = 1;
 469                                 for (Entry<String, URL> chap : chapters) {
 470                                         pgChaps.setName("Extracting chapter " + i);
 471                                         InputStream chapIn = null;
 472                                         if (chap.getValue() != null) {
 473                                                 setCurrentReferer(chap.getValue());
 474                                                 chapIn = Instance.getCache().open(chap.getValue(),
 475                                                                 this, true);
 476                                         }
 477                                         pgChaps.setProgress(i * 100);
 478                                         try {
 479                                                 Progress pgGetChapterContent = new Progress();
 480                                                 Progress pgMakeChapter = new Progress();
 481                                                 pgChaps.addProgress(pgGetChapterContent, 100);
 482                                                 pgChaps.addProgress(pgMakeChapter, 100);
 483
 484                                                 String content = getChapterContent(url, chapIn, i,
 485                                                                 pgGetChapterContent);
 486                                                 if (!pgGetChapterContent.isDone()) {
 487                                                         pgGetChapterContent.setProgress(pgGetChapterContent
 488                                                                         .getMax());
 489                                                 }
 490
 491                                                 Chapter cc = makeChapter(url, i, chap.getKey(),
 492                                                                 content, pgMakeChapter);
 493                                                 if (!pgMakeChapter.isDone()) {
 494                                                         pgMakeChapter.setProgress(pgMakeChapter.getMax());
 495                                                 }
 496
 497                                                 words += cc.getWords();
 498                                                 story.getChapters().add(cc);
 499                                                 if (story.getMeta() != null) {
 500                                                         story.getMeta().setWords(words);
 501                                                 }
 502                                         } finally {
 503                                                 if (chapIn != null) {
 504                                                         chapIn.close();
 505                                                 }
 506                                         }
 507
 508                                         i++;
 509                                 }
 510
 511                                 pgChaps.setName("Extracting chapters");
 512                         } else {
 513                                 pg.setProgress(80);
 514                         }
 515
 516                         return story;
 517
 518                 } finally {
 519                         try {
 520                                 close();
 521                         } catch (IOException e) {
 522                                 Instance.getTraceHandler().error(e);
 523                         }
 524
 525                         if (in != null) {
 526                                 in.close();
 527                         }
 528
 529                         setCurrentReferer(null);
 530                 }
 531         }
 532
 533         /**
 534          * The support type.
 535          *
 536          * @return the type
 537          */
 538         public SupportType getType() {
 539                 return type;
 540         }
 541
 542         /**
 543          * The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
 544          * the current {@link URL} we work on.
 545          *
 546          * @return the referer
 547          */
 548         public URL getCurrentReferer() {
 549                 return currentReferer;
 550         }
 551
 552         /**
 553          * The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
 554          * the current {@link URL} we work on.
 555          *
 556          * @param currentReferer
 557          *            the new referer
 558          */
 559         protected void setCurrentReferer(URL currentReferer) {
 560                 this.currentReferer = currentReferer;
 561         }
 562
 563         /**
 564          * The support type.
 565          *
 566          * @param type
 567          *            the new type
 568          *
 569          * @return this
 570          */
 571         protected BasicSupport setType(SupportType type) {
 572                 this.type = type;
 573                 return this;
 574         }
 575
 576         /**
 577          * Prepare the support if needed before processing.
 578          *
 579          * @param source
 580          *            the source of the story
 581          * @param in
 582          *            the input (the main resource)
 583          *
 584          * @throws IOException
 585          *             on I/O error
 586          */
 587         @SuppressWarnings("unused")
 588         protected void preprocess(URL source, InputStream in) throws IOException {
 589         }
 590
 591         /**
 592          * Now that we have processed the {@link Story}, close the resources if any.
 593          *
 594          * @throws IOException
 595          *             on I/O error
 596          */
 597         @SuppressWarnings("unused")
 598         protected void close() throws IOException {
 599         }
 600
 601         /**
 602          * Create a {@link Chapter} object from the given information, formatting
 603          * the content as it should be.
 604          *
 605          * @param source
 606          *            the source of the story
 607          * @param number
 608          *            the chapter number
 609          * @param name
 610          *            the chapter name
 611          * @param content
 612          *            the chapter content
 613          * @param pg
 614          *            the optional progress reporter
 615          *
 616          * @return the {@link Chapter}
 617          *
 618          * @throws IOException
 619          *             in case of I/O error
 620          */
 621         protected Chapter makeChapter(URL source, int number, String name,
 622                         String content, Progress pg) throws IOException {
 623                 // Chapter name: process it correctly, then remove the possible
 624                 // redundant "Chapter x: " in front of it, or "-" (as in
 625                 // "Chapter 5: - Fun!" after the ": " was automatically added)
 626                 String chapterName = processPara(name).getContent().trim();
 627                 for (String lang : Instance.getConfig().getString(Config.CHAPTER)
 628                                 .split(",")) {
 629                         String chapterWord = Instance.getConfig().getStringX(
 630                                         Config.CHAPTER, lang);
 631                         if (chapterName.startsWith(chapterWord)) {
 632                                 chapterName = chapterName.substring(chapterWord.length())
 633                                                 .trim();
 634                                 break;
 635                         }
 636                 }
 637
 638                 if (chapterName.startsWith(Integer.toString(number))) {
 639                         chapterName = chapterName.substring(
 640                                         Integer.toString(number).length()).trim();
 641                 }
 642
 643                 while (chapterName.startsWith(":") || chapterName.startsWith("-")) {
 644                         chapterName = chapterName.substring(1).trim();
 645                 }
 646                 //
 647
 648                 Chapter chap = new Chapter(number, chapterName);
 649
 650                 if (content != null) {
 651                         List<Paragraph> paras = makeParagraphs(source, content, pg);
 652                         long words = 0;
 653                         for (Paragraph para : paras) {
 654                                 words += para.getWords();
 655                         }
 656                         chap.setParagraphs(paras);
 657                         chap.setWords(words);
 658                 }
 659
 660                 return chap;
 661
 662         }
 663
 664         /**
 665          * Convert the given content into {@link Paragraph}s.
 666          *
 667          * @param source
 668          *            the source URL of the story
 669          * @param content
 670          *            the textual content
 671          * @param pg
 672          *            the optional progress reporter
 673          *
 674          * @return the {@link Paragraph}s
 675          *
 676          * @throws IOException
 677          *             in case of I/O error
 678          */
 679         protected List<Paragraph> makeParagraphs(URL source, String content,
 680                         Progress pg) throws IOException {
 681                 if (pg == null) {
 682                         pg = new Progress();
 683                 }
 684
 685                 if (isHtml()) {
 686                         // Special <HR> processing:
 687                         content = content.replaceAll("(<hr [^>]*>)|(<hr/>)|(<hr>)",
 688                                         "<br/>* * *<br/>");
 689                 }
 690
 691                 List<Paragraph> paras = new ArrayList<Paragraph>();
 692
 693                 if (content != null && !content.trim().isEmpty()) {
 694                         if (isHtml()) {
 695                                 String[] tab = content.split("(<p>|</p>|<br>|<br/>)");
 696                                 pg.setMinMax(0, tab.length);
 697                                 int i = 1;
 698                                 for (String line : tab) {
 699                                         if (line.startsWith("[") && line.endsWith("]")) {
 700                                                 pg.setName("Extracting image " + i);
 701                                         }
 702                                         paras.add(makeParagraph(source, line.trim()));
 703                                         pg.setProgress(i++);
 704                                 }
 705                                 pg.setName(null);
 706                         } else {
 707                                 List<String> lines = new ArrayList<String>();
 708                                 BufferedReader buff = null;
 709                                 try {
 710                                         buff = new BufferedReader(
 711                                                         new InputStreamReader(new ByteArrayInputStream(
 712                                                                         content.getBytes("UTF-8")), "UTF-8"));
 713                                         for (String line = buff.readLine(); line != null; line = buff
 714                                                         .readLine()) {
 715                                                 lines.add(line.trim());
 716                                         }
 717                                 } finally {
 718                                         if (buff != null) {
 719                                                 buff.close();
 720                                         }
 721                                 }
 722
 723                                 pg.setMinMax(0, lines.size());
 724                                 int i = 0;
 725                                 for (String line : lines) {
 726                                         if (line.startsWith("[") && line.endsWith("]")) {
 727                                                 pg.setName("Extracting image " + i);
 728                                         }
 729                                         paras.add(makeParagraph(source, line));
 730                                         pg.setProgress(i++);
 731                                 }
 732                                 pg.setName(null);
 733                         }
 734
 735                         // Check quotes for "bad" format
 736                         List<Paragraph> newParas = new ArrayList<Paragraph>();
 737                         for (Paragraph para : paras) {
 738                                 newParas.addAll(requotify(para));
 739                         }
 740                         paras = newParas;
 741
 742                         // Remove double blanks/brks
 743                         fixBlanksBreaks(paras);
 744                 }
 745
 746                 return paras;
 747         }
 748
 749         /**
 750          * Convert the given line into a single {@link Paragraph}.
 751          *
 752          * @param source
 753          *            the source URL of the story
 754          * @param line
 755          *            the textual content of the paragraph
 756          *
 757          * @return the {@link Paragraph}
 758          */
 759         private Paragraph makeParagraph(URL source, String line) {
 760                 BufferedImage image = null;
 761                 if (line.startsWith("[") && line.endsWith("]")) {
 762                         image = getImage(this, source, line.substring(1, line.length() - 1)
 763                                         .trim());
 764                 }
 765
 766                 if (image != null) {
 767                         return new Paragraph(image);
 768                 }
 769
 770                 return processPara(line);
 771         }
 772
 773         /**
 774          * Fix the {@link ParagraphType#BLANK}s and {@link ParagraphType#BREAK}s of
 775          * those {@link Paragraph}s.
 776          * <p>
 777          * The resulting list will not contain a starting or trailing blank/break
 778          * nor 2 blanks or breaks following each other.
 779          *
 780          * @param paras
 781          *            the list of {@link Paragraph}s to fix
 782          */
 783         protected void fixBlanksBreaks(List<Paragraph> paras) {
 784                 boolean space = false;
 785                 boolean brk = true;
 786                 for (int i = 0; i < paras.size(); i++) {
 787                         Paragraph para = paras.get(i);
 788                         boolean thisSpace = para.getType() == ParagraphType.BLANK;
 789                         boolean thisBrk = para.getType() == ParagraphType.BREAK;
 790
 791                         if (i > 0 && space && thisBrk) {
 792                                 paras.remove(i - 1);
 793                                 i--;
 794                         } else if ((space || brk) && (thisSpace || thisBrk)) {
 795                                 paras.remove(i);
 796                                 i--;
 797                         }
 798
 799                         space = thisSpace;
 800                         brk = thisBrk;
 801                 }
 802
 803                 // Remove blank/brk at start
 804                 if (paras.size() > 0
 805                                 && (paras.get(0).getType() == ParagraphType.BLANK || paras.get(
 806                                                 0).getType() == ParagraphType.BREAK)) {
 807                         paras.remove(0);
 808                 }
 809
 810                 // Remove blank/brk at end
 811                 int last = paras.size() - 1;
 812                 if (paras.size() > 0
 813                                 && (paras.get(last).getType() == ParagraphType.BLANK || paras
 814                                                 .get(last).getType() == ParagraphType.BREAK)) {
 815                         paras.remove(last);
 816                 }
 817         }
 818
 819         /**
 820          * Get the default cover related to this subject (see <tt>.info</tt> files).
 821          *
 822          * @param subject
 823          *            the subject
 824          *
 825          * @return the cover if any, or NULL
 826          */
 827         static BufferedImage getDefaultCover(String subject) {
 828                 if (subject != null && !subject.isEmpty()
 829                                 && Instance.getCoverDir() != null) {
 830                         try {
 831                                 File fileCover = new File(Instance.getCoverDir(), subject);
 832                                 return getImage(null, fileCover.toURI().toURL(), subject);
 833                         } catch (MalformedURLException e) {
 834                         }
 835                 }
 836
 837                 return null;
 838         }
 839
 840         /**
 841          * Return the list of supported image extensions.
 842          *
 843          * @param emptyAllowed
 844          *            TRUE to allow an empty extension on first place, which can be
 845          *            used when you may already have an extension in your input but
 846          *            are not sure about it
 847          *
 848          * @return the extensions
 849          */
 850         static String[] getImageExt(boolean emptyAllowed) {
 851                 if (emptyAllowed) {
 852                         return new String[] { "", ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
 853                 }
 854
 855                 return new String[] { ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
 856         }
 857
 858         /**
 859          * Check if the given resource can be a local image or a remote image, then
 860          * refresh the cache with it if it is.
 861          *
 862          * @param source
 863          *            the story source
 864          * @param line
 865          *            the resource to check
 866          *
 867          * @return the image if found, or NULL
 868          *
 869          */
 870         static BufferedImage getImage(BasicSupport support, URL source, String line) {
 871                 URL url = getImageUrl(support, source, line);
 872                 if (url != null) {
 873                         InputStream in = null;
 874                         try {
 875                                 in = Instance.getCache().open(url, getSupport(url), true);
 876                                 return ImageUtils.fromStream(in);
 877                         } catch (IOException e) {
 878                         } finally {
 879                                 if (in != null) {
 880                                         try {
 881                                                 in.close();
 882                                         } catch (IOException e) {
 883                                         }
 884                                 }
 885                         }
 886                 }
 887
 888                 return null;
 889         }
 890
 891         /**
 892          * Check if the given resource can be a local image or a remote image, then
 893          * refresh the cache with it if it is.
 894          *
 895          * @param source
 896          *            the story source
 897          * @param line
 898          *            the resource to check
 899          *
 900          * @return the image URL if found, or NULL
 901          *
 902          */
 903         static URL getImageUrl(BasicSupport support, URL source, String line) {
 904                 URL url = null;
 905
 906                 if (line != null) {
 907                         // try for files
 908                         if (source != null) {
 909                                 try {
 910
 911                                         String relPath = null;
 912                                         String absPath = null;
 913                                         try {
 914                                                 String path = new File(source.getFile()).getParent();
 915                                                 relPath = new File(new File(path), line.trim())
 916                                                                 .getAbsolutePath();
 917                                         } catch (Exception e) {
 918                                                 // Cannot be converted to path (one possibility to take
 919                                                 // into account: absolute path on Windows)
 920                                         }
 921                                         try {
 922                                                 absPath = new File(line.trim()).getAbsolutePath();
 923                                         } catch (Exception e) {
 924                                                 // Cannot be converted to path (at all)
 925                                         }
 926
 927                                         for (String ext : getImageExt(true)) {
 928                                                 if (absPath != null && new File(absPath + ext).exists()) {
 929                                                         url = new File(absPath + ext).toURI().toURL();
 930                                                 } else if (relPath != null
 931                                                                 && new File(relPath + ext).exists()) {
 932                                                         url = new File(relPath + ext).toURI().toURL();
 933                                                 }
 934                                         }
 935                                 } catch (Exception e) {
 936                                         // Should not happen since we control the correct arguments
 937                                 }
 938                         }
 939
 940                         if (url == null) {
 941                                 // try for URLs
 942                                 try {
 943                                         for (String ext : getImageExt(true)) {
 944                                                 if (Instance.getCache()
 945                                                                 .check(new URL(line + ext), true)) {
 946                                                         url = new URL(line + ext);
 947                                                         break;
 948                                                 }
 949                                         }
 950
 951                                         // try out of cache
 952                                         if (url == null) {
 953                                                 for (String ext : getImageExt(true)) {
 954                                                         try {
 955                                                                 url = new URL(line + ext);
 956                                                                 Instance.getCache().refresh(url, support, true);
 957                                                                 break;
 958                                                         } catch (IOException e) {
 959                                                                 // no image with this ext
 960                                                                 url = null;
 961                                                         }
 962                                                 }
 963                                         }
 964                                 } catch (MalformedURLException e) {
 965                                         // Not an url
 966                                 }
 967                         }
 968
 969                         // refresh the cached file
 970                         if (url != null) {
 971                                 try {
 972                                         Instance.getCache().refresh(url, support, true);
 973                                 } catch (IOException e) {
 974                                         // woops, broken image
 975                                         url = null;
 976                                 }
 977                         }
 978                 }
 979
 980                 return url;
 981         }
 982
 983         /**
 984          * Open the input file that will be used through the support.
 985          * <p>
 986          * Can return NULL, in which case you are supposed to work without an
 987          * {@link InputStream}.
 988          *
 989          * @param source
 990          *            the source {@link URL}
 991          *
 992          * @return the {@link InputStream}
 993          *
 994          * @throws IOException
 995          *             in case of I/O error
 996          */
 997         protected InputStream openInput(URL source) throws IOException {
 998                 return Instance.getCache().open(source, this, false);
 999         }
1000
1001         /**
1002          * Reset then return {@link BasicSupport#in}.
1003          *
1004          * @return {@link BasicSupport#in}
1005          */
1006         protected InputStream getInput() {
1007                 return reset(in);
1008         }
1009
1010         /**
1011          * Fix the author name if it is prefixed with some "by" {@link String}.
1012          *
1013          * @param author
1014          *            the author with a possible prefix
1015          *
1016          * @return the author without prefixes
1017          */
1018         protected String fixAuthor(String author) {
1019                 if (author != null) {
1020                         for (String suffix : new String[] { " ", ":" }) {
1021                                 for (String byString : Instance.getConfig()
1022                                                 .getString(Config.BYS).split(",")) {
1023                                         byString += suffix;
1024                                         if (author.toUpperCase().startsWith(byString.toUpperCase())) {
1025                                                 author = author.substring(byString.length()).trim();
1026                                         }
1027                                 }
1028                         }
1029
1030                         // Special case (without suffix):
1031                         if (author.startsWith("©")) {
1032                                 author = author.substring(1);
1033                         }
1034                 }
1035
1036                 return author;
1037         }
1038
1039         /**
1040          * Check quotes for bad format (i.e., quotes with normal paragraphs inside)
1041          * and requotify them (i.e., separate them into QUOTE paragraphs and other
1042          * paragraphs (quotes or not)).
1043          *
1044          * @param para
1045          *            the paragraph to requotify (not necessarily a quote)
1046          *
1047          * @return the correctly (or so we hope) quotified paragraphs
1048          */
1049         protected List<Paragraph> requotify(Paragraph para) {
1050                 List<Paragraph> newParas = new ArrayList<Paragraph>();
1051
1052                 if (para.getType() == ParagraphType.QUOTE
1053                                 && para.getContent().length() > 2) {
1054                         String line = para.getContent();
1055                         boolean singleQ = line.startsWith("" + openQuote);
1056                         boolean doubleQ = line.startsWith("" + openDoubleQuote);
1057
1058                         // Do not try when more than one quote at a time
1059                         // (some stories are not easily readable if we do)
1060                         if (singleQ
1061                                         && line.indexOf(closeQuote, 1) < line
1062                                                         .lastIndexOf(closeQuote)) {
1063                                 newParas.add(para);
1064                                 return newParas;
1065                         }
1066                         if (doubleQ
1067                                         && line.indexOf(closeDoubleQuote, 1) < line
1068                                                         .lastIndexOf(closeDoubleQuote)) {
1069                                 newParas.add(para);
1070                                 return newParas;
1071                         }
1072                         //
1073
1074                         if (!singleQ && !doubleQ) {
1075                                 line = openDoubleQuote + line + closeDoubleQuote;
1076                                 newParas.add(new Paragraph(ParagraphType.QUOTE, line, para
1077                                                 .getWords()));
1078                         } else {
1079                                 char open = singleQ ? openQuote : openDoubleQuote;
1080                                 char close = singleQ ? closeQuote : closeDoubleQuote;
1081
1082                                 int posDot = -1;
1083                                 boolean inQuote = false;
1084                                 int i = 0;
1085                                 for (char car : line.toCharArray()) {
1086                                         if (car == open) {
1087                                                 inQuote = true;
1088                                         } else if (car == close) {
1089                                                 inQuote = false;
1090                                         } else if (car == '.' && !inQuote) {
1091                                                 posDot = i;
1092                                                 break;
1093                                         }
1094                                         i++;
1095                                 }
1096
1097                                 if (posDot >= 0) {
1098                                         String rest = line.substring(posDot + 1).trim();
1099                                         line = line.substring(0, posDot + 1).trim();
1100                                         long words = 1;
1101                                         for (char car : line.toCharArray()) {
1102                                                 if (car == ' ') {
1103                                                         words++;
1104                                                 }
1105                                         }
1106                                         newParas.add(new Paragraph(ParagraphType.QUOTE, line, words));
1107                                         if (!rest.isEmpty()) {
1108                                                 newParas.addAll(requotify(processPara(rest)));
1109                                         }
1110                                 } else {
1111                                         newParas.add(para);
1112                                 }
1113                         }
1114                 } else {
1115                         newParas.add(para);
1116                 }
1117
1118                 return newParas;
1119         }
1120
1121         /**
1122          * Process a {@link Paragraph} from a raw line of text.
1123          * <p>
1124          * Will also fix quotes and HTML encoding if needed.
1125          *
1126          * @param line
1127          *            the raw line
1128          *
1129          * @return the processed {@link Paragraph}
1130          */
1131         protected Paragraph processPara(String line) {
1132                 line = ifUnhtml(line).trim();
1133
1134                 boolean space = true;
1135                 boolean brk = true;
1136                 boolean quote = false;
1137                 boolean tentativeCloseQuote = false;
1138                 char prev = '\0';
1139                 int dashCount = 0;
1140                 long words = 1;
1141
1142                 StringBuilder builder = new StringBuilder();
1143                 for (char car : line.toCharArray()) {
1144                         if (car != '-') {
1145                                 if (dashCount > 0) {
1146                                         // dash, ndash and mdash: - – —
1147                                         // currently: always use mdash
1148                                         builder.append(dashCount == 1 ? '-' : '—');
1149                                 }
1150                                 dashCount = 0;
1151                         }
1152
1153                         if (tentativeCloseQuote) {
1154                                 tentativeCloseQuote = false;
1155                                 if (Character.isLetterOrDigit(car)) {
1156                                         builder.append("'");
1157                                 } else {
1158                                         // handle double-single quotes as double quotes
1159                                         if (prev == car) {
1160                                                 builder.append(closeDoubleQuote);
1161                                                 continue;
1162                                         }
1163
1164                                         builder.append(closeQuote);
1165                                 }
1166                         }
1167
1168                         switch (car) {
1169                         case ' ': // note: unbreakable space
1170                         case ' ':
1171                         case '\t':
1172                         case '\n': // just in case
1173                         case '\r': // just in case
1174                                 if (builder.length() > 0
1175                                                 && builder.charAt(builder.length() - 1) != ' ') {
1176                                         words++;
1177                                 }
1178                                 builder.append(' ');
1179                                 break;
1180
1181                         case '\'':
1182                                 if (space || (brk && quote)) {
1183                                         quote = true;
1184                                         // handle double-single quotes as double quotes
1185                                         if (prev == car) {
1186                                                 builder.deleteCharAt(builder.length() - 1);
1187                                                 builder.append(openDoubleQuote);
1188                                         } else {
1189                                                 builder.append(openQuote);
1190                                         }
1191                                 } else if (prev == ' ' || prev == car) {
1192                                         // handle double-single quotes as double quotes
1193                                         if (prev == car) {
1194                                                 builder.deleteCharAt(builder.length() - 1);
1195                                                 builder.append(openDoubleQuote);
1196                                         } else {
1197                                                 builder.append(openQuote);
1198                                         }
1199                                 } else {
1200                                         // it is a quote ("I'm off") or a 'quote' ("This
1201                                         // 'good' restaurant"...)
1202                                         tentativeCloseQuote = true;
1203                                 }
1204                                 break;
1205
1206                         case '"':
1207                                 if (space || (brk && quote)) {
1208                                         quote = true;
1209                                         builder.append(openDoubleQuote);
1210                                 } else if (prev == ' ') {
1211                                         builder.append(openDoubleQuote);
1212                                 } else {
1213                                         builder.append(closeDoubleQuote);
1214                                 }
1215                                 break;
1216
1217                         case '-':
1218                                 if (space) {
1219                                         quote = true;
1220                                 } else {
1221                                         dashCount++;
1222                                 }
1223                                 space = false;
1224                                 break;
1225
1226                         case '*':
1227                         case '~':
1228                         case '/':
1229                         case '\\':
1230                         case '<':
1231                         case '>':
1232                         case '=':
1233                         case '+':
1234                         case '_':
1235                         case '–':
1236                         case '—':
1237                                 space = false;
1238                                 builder.append(car);
1239                                 break;
1240
1241                         case '‘':
1242                         case '`':
1243                         case '‹':
1244                         case '﹁':
1245                         case '〈':
1246                         case '「':
1247                                 if (space || (brk && quote)) {
1248                                         quote = true;
1249                                         builder.append(openQuote);
1250                                 } else {
1251                                         // handle double-single quotes as double quotes
1252                                         if (prev == car) {
1253                                                 builder.deleteCharAt(builder.length() - 1);
1254                                                 builder.append(openDoubleQuote);
1255                                         } else {
1256                                                 builder.append(openQuote);
1257                                         }
1258                                 }
1259                                 space = false;
1260                                 brk = false;
1261                                 break;
1262
1263                         case '’':
1264                         case '›':
1265                         case '﹂':
1266                         case '〉':
1267                         case '」':
1268                                 space = false;
1269                                 brk = false;
1270                                 // handle double-single quotes as double quotes
1271                                 if (prev == car) {
1272                                         builder.deleteCharAt(builder.length() - 1);
1273                                         builder.append(closeDoubleQuote);
1274                                 } else {
1275                                         builder.append(closeQuote);
1276                                 }
1277                                 break;
1278
1279                         case '«':
1280                         case '“':
1281                         case '﹃':
1282                         case '《':
1283                         case '『':
1284                                 if (space || (brk && quote)) {
1285                                         quote = true;
1286                                         builder.append(openDoubleQuote);
1287                                 } else {
1288                                         builder.append(openDoubleQuote);
1289                                 }
1290                                 space = false;
1291                                 brk = false;
1292                                 break;
1293
1294                         case '»':
1295                         case '”':
1296                         case '﹄':
1297                         case '》':
1298                         case '』':
1299                                 space = false;
1300                                 brk = false;
1301                                 builder.append(closeDoubleQuote);
1302                                 break;
1303
1304                         default:
1305                                 space = false;
1306                                 brk = false;
1307                                 builder.append(car);
1308                                 break;
1309                         }
1310
1311                         prev = car;
1312                 }
1313
1314                 if (tentativeCloseQuote) {
1315                         tentativeCloseQuote = false;
1316                         builder.append(closeQuote);
1317                 }
1318
1319                 line = builder.toString().trim();
1320
1321                 ParagraphType type = ParagraphType.NORMAL;
1322                 if (space) {
1323                         type = ParagraphType.BLANK;
1324                 } else if (brk) {
1325                         type = ParagraphType.BREAK;
1326                 } else if (quote) {
1327                         type = ParagraphType.QUOTE;
1328                 }
1329
1330                 return new Paragraph(type, line, words);
1331         }
1332
1333         /**
1334          * Remove the HTML from the input <b>if</b> {@link BasicSupport#isHtml()} is
1335          * true.
1336          *
1337          * @param input
1338          *            the input
1339          *
1340          * @return the no html version if needed
1341          */
1342         private String ifUnhtml(String input) {
1343                 if (isHtml() && input != null) {
1344                         return StringUtils.unhtml(input);
1345                 }
1346
1347                 return input;
1348         }
1349
1350         /**
1351          * Return a {@link BasicSupport} implementation supporting the given
1352          * resource if possible.
1353          *
1354          * @param url
1355          *            the story resource
1356          *
1357          * @return an implementation that supports it, or NULL
1358          */
1359         public static BasicSupport getSupport(URL url) {
1360                 if (url == null) {
1361                         return null;
1362                 }
1363
1364                 // TEXT and INFO_TEXT always support files (not URLs though)
1365                 for (SupportType type : SupportType.values()) {
1366                         if (type != SupportType.TEXT && type != SupportType.INFO_TEXT) {
1367                                 BasicSupport support = getSupport(type);
1368                                 if (support != null && support.supports(url)) {
1369                                         return support;
1370                                 }
1371                         }
1372                 }
1373
1374                 for (SupportType type : new SupportType[] { SupportType.INFO_TEXT,
1375                                 SupportType.TEXT }) {
1376                         BasicSupport support = getSupport(type);
1377                         if (support != null && support.supports(url)) {
1378                                 return support;
1379                         }
1380                 }
1381
1382                 return null;
1383         }
1384
1385         /**
1386          * Return a {@link BasicSupport} implementation supporting the given type.
1387          *
1388          * @param type
1389          *            the type
1390          *
1391          * @return an implementation that supports it, or NULL
1392          */
1393         public static BasicSupport getSupport(SupportType type) {
1394                 switch (type) {
1395                 case EPUB:
1396                         return new Epub().setType(type);
1397                 case INFO_TEXT:
1398                         return new InfoText().setType(type);
1399                 case FIMFICTION:
1400                         try {
1401                                 // Can fail if no client key or NO in options
1402                                 return new FimfictionApi().setType(type);
1403                         } catch (IOException e) {
1404                                 return new Fimfiction().setType(type);
1405                         }
1406                 case FANFICTION:
1407                         return new Fanfiction().setType(type);
1408                 case TEXT:
1409                         return new Text().setType(type);
1410                 case MANGAFOX:
1411                         return new MangaFox().setType(type);
1412                 case E621:
1413                         return new E621().setType(type);
1414                 case YIFFSTAR:
1415                         return new YiffStar().setType(type);
1416                 case E_HENTAI:
1417                         return new EHentai().setType(type);
1418                 case CBZ:
1419                         return new Cbz().setType(type);
1420                 case HTML:
1421                         return new Html().setType(type);
1422                 }
1423
1424                 return null;
1425         }
1426
1427         /**
1428          * Reset the given {@link InputStream} and return it.
1429          *
1430          * @param in
1431          *            the {@link InputStream} to reset
1432          *
1433          * @return the same {@link InputStream} after reset
1434          */
1435         static protected InputStream reset(InputStream in) {
1436                 try {
1437                         if (in != null) {
1438                                 in.reset();
1439                         }
1440                 } catch (IOException e) {
1441                 }
1442
1443                 return in;
1444         }
1445
1446         /**
1447          * Return the first line from the given input which correspond to the given
1448          * selectors.
1449          *
1450          * @param in
1451          *            the input
1452          * @param needle
1453          *            a string that must be found inside the target line (also
1454          *            supports "^" at start to say "only if it starts with" the
1455          *            needle)
1456          * @param relativeLine
1457          *            the line to return based upon the target line position (-1 =
1458          *            the line before, 0 = the target line...)
1459          *
1460          * @return the line
1461          */
1462         static protected String getLine(InputStream in, String needle,
1463                         int relativeLine) {
1464                 return getLine(in, needle, relativeLine, true);
1465         }
1466
1467         /**
1468          * Return a line from the given input which correspond to the given
1469          * selectors.
1470          *
1471          * @param in
1472          *            the input
1473          * @param needle
1474          *            a string that must be found inside the target line (also
1475          *            supports "^" at start to say "only if it starts with" the
1476          *            needle)
1477          * @param relativeLine
1478          *            the line to return based upon the target line position (-1 =
1479          *            the line before, 0 = the target line...)
1480          * @param first
1481          *            takes the first result (as opposed to the last one, which will
1482          *            also always spend the input)
1483          *
1484          * @return the line
1485          */
1486         static protected String getLine(InputStream in, String needle,
1487                         int relativeLine, boolean first) {
1488                 String rep = null;
1489
1490                 reset(in);
1491
1492                 List<String> lines = new ArrayList<String>();
1493                 @SuppressWarnings("resource")
1494                 Scanner scan = new Scanner(in, "UTF-8");
1495                 int index = -1;
1496                 scan.useDelimiter("\\n");
1497                 while (scan.hasNext()) {
1498                         lines.add(scan.next());
1499
1500                         if (index == -1) {
1501                                 if (needle.startsWith("^")) {
1502                                         if (lines.get(lines.size() - 1).startsWith(
1503                                                         needle.substring(1))) {
1504                                                 index = lines.size() - 1;
1505                                         }
1506
1507                                 } else {
1508                                         if (lines.get(lines.size() - 1).contains(needle)) {
1509                                                 index = lines.size() - 1;
1510                                         }
1511                                 }
1512                         }
1513
1514                         if (index >= 0 && index + relativeLine < lines.size()) {
1515                                 rep = lines.get(index + relativeLine);
1516                                 if (first) {
1517                                         break;
1518                                 }
1519                         }
1520                 }
1521
1522                 return rep;
1523         }
1524
1525         /**
1526          * Return the text between the key and the endKey (and optional subKey can
1527          * be passed, in this case we will look for the key first, then take the
1528          * text between the subKey and the endKey).
1529          * <p>
1530          * Will only match the first line with the given key if more than one are
1531          * possible. Which also means that if the subKey or endKey is not found on
1532          * that line, NULL will be returned.
1533          *
1534          * @param in
1535          *            the input
1536          * @param key
1537          *            the key to match (also supports "^" at start to say
1538          *            "only if it starts with" the key)
1539          * @param subKey
1540          *            the sub key or NULL if none
1541          * @param endKey
1542          *            the end key or NULL for "up to the end"
1543          * @return the text or NULL if not found
1544          */
1545         static protected String getKeyLine(InputStream in, String key,
1546                         String subKey, String endKey) {
1547                 return getKeyText(getLine(in, key, 0), key, subKey, endKey);
1548         }
1549
1550         /**
1551          * Return the text between the key and the endKey (and optional subKey can
1552          * be passed, in this case we will look for the key first, then take the
1553          * text between the subKey and the endKey).
1554          *
1555          * @param in
1556          *            the input
1557          * @param key
1558          *            the key to match (also supports "^" at start to say
1559          *            "only if it starts with" the key)
1560          * @param subKey
1561          *            the sub key or NULL if none
1562          * @param endKey
1563          *            the end key or NULL for "up to the end"
1564          * @return the text or NULL if not found
1565          */
1566         static protected String getKeyText(String in, String key, String subKey,
1567                         String endKey) {
1568                 String result = null;
1569
1570                 String line = in;
1571                 if (line != null && line.contains(key)) {
1572                         line = line.substring(line.indexOf(key) + key.length());
1573                         if (subKey == null || subKey.isEmpty() || line.contains(subKey)) {
1574                                 if (subKey != null) {
1575                                         line = line.substring(line.indexOf(subKey)
1576                                                         + subKey.length());
1577                                 }
1578                                 if (endKey == null || line.contains(endKey)) {
1579                                         if (endKey != null) {
1580                                                 line = line.substring(0, line.indexOf(endKey));
1581                                                 result = line;
1582                                         }
1583                                 }
1584                         }
1585                 }
1586
1587                 return result;
1588         }
1589
1590         /**
1591          * Return the text between the key and the endKey (optional subKeys can be
1592          * passed, in this case we will look for the subKeys first, then take the
1593          * text between the key and the endKey).
1594          *
1595          * @param in
1596          *            the input
1597          * @param key
1598          *            the key to match
1599          * @param endKey
1600          *            the end key or NULL for "up to the end"
1601          * @param afters
1602          *            the sub-keys to find before checking for key/endKey
1603          *
1604          * @return the text or NULL if not found
1605          */
1606         static protected String getKeyTextAfter(String in, String key,
1607                         String endKey, String... afters) {
1608
1609                 if (in != null && !in.isEmpty()) {
1610                         int pos = indexOfAfter(in, 0, afters);
1611                         if (pos < 0) {
1612                                 return null;
1613                         }
1614
1615                         in = in.substring(pos);
1616                 }
1617
1618                 return getKeyText(in, key, null, endKey);
1619         }
1620
1621         /**
1622          * Return the first index after all the given "afters" have been found in
1623          * the {@link String}, or -1 if it was not possible.
1624          *
1625          * @param in
1626          *            the input
1627          * @param startAt
1628          *            start at this position in the string
1629          * @param afters
1630          *            the sub-keys to find before checking for key/endKey
1631          *
1632          * @return the text or NULL if not found
1633          */
1634         static protected int indexOfAfter(String in, int startAt, String... afters) {
1635                 int pos = -1;
1636                 if (in != null && !in.isEmpty()) {
1637                         pos = startAt;
1638                         if (afters != null) {
1639                                 for (int i = 0; pos >= 0 && i < afters.length; i++) {
1640                                         String subKey = afters[i];
1641                                         if (!subKey.isEmpty()) {
1642                                                 pos = in.indexOf(subKey, pos);
1643                                                 if (pos >= 0) {
1644                                                         pos += subKey.length();
1645                                                 }
1646                                         }
1647                                 }
1648                         }
1649                 }
1650
1651                 return pos;
1652         }
1653 }