def recode_wgsim_reads(
        rnf_fastq_fo,
        fai_fo,
        genome_id,
        wgsim_fastq_1_fn,
        wgsim_fastq_2_fn=None,
        number_of_read_tuples=10**9,
    ):
        """Convert WgSim FASTQ files to RNF FASTQ files.

		Args:
			rnf_fastq_fo (file): File object of the target RNF file.
			fai_fo (file): File object of FAI index of the reference genome.
			genome_id (int): RNF genome ID.
			wgsim_fastq_1_fn (str): File name of the first WgSim FASTQ file.
			wgsim_fastq_2_fn (str): File name of the second WgSim FASTQ file.
			number_of_read_tuples (int): Expected number of read tuples (to estimate widths).
		"""

        wgsim_pattern = re.compile(
            '@(.*)_([0-9]+)_([0-9]+)_([0-9]+):([0-9]+):([0-9]+)_([0-9]+):([0-9]+):([0-9]+)_([0-9a-f]+)/([12])'
        )
        """
			WGSIM read name format

		1)  contig name (chromsome name)
		2)  start end 1 (one-based)
		3)  end end 2 (one-based)
		4)  number of errors end 1
		5)  number of substitutions end 1
		6)  number of indels end 1
		5)  number of errors end 2
		6)  number of substitutions end 2
		7)  number of indels end 2
		10) id
		11) pair
		"""

        fai_index = rnftools.utils.FaIdx(fai_fo)
        read_tuple_id_width = len(format(number_of_read_tuples, 'x'))

        last_read_tuple_name = None

        fq_creator = rnftools.rnfformat.FqCreator(
            fastq_fo=rnf_fastq_fo,
            read_tuple_id_width=read_tuple_id_width,
            genome_id_width=2,
            chr_id_width=fai_index.chr_id_width,
            coor_width=fai_index.coor_width,
            info_reads_in_tuple=True,
            info_simulator="wgsim",
        )

        reads_in_tuple = 2
        if wgsim_fastq_2_fn is None:
            reads_in_tuple = 1

        i = 0
        with open(wgsim_fastq_1_fn, "r+") as f_inp_1:
            if reads_in_tuple == 2:
                # todo: close file
                f_inp_2 = open(wgsim_fastq_2_fn)

            for line_a in f_inp_1:
                lines = [line_a.strip()]
                if reads_in_tuple == 2:
                    lines.append(f_inp_2.readline().strip())

                if i % 4 == 0:
                    segments = []
                    # bases=[]
                    # qualities=[]

                    m = wgsim_pattern.search(lines[0])
                    if m is None:
                        rnftools.utils.error(
                            "Read tuple '{}' was not generated by WgSim.".format(lines[0][1:]), program="RNFtools",
                            subprogram="MIShmash", exception=ValueError
                        )

                    contig_name = m.group(1)
                    start_1 = int(m.group(2))
                    end_2 = int(m.group(3))
                    errors_1 = int(m.group(4))
                    substitutions_1 = int(m.group(5))
                    indels_1 = int(m.group(6))
                    errors_2 = int(m.group(7))
                    substitutions_2 = int(m.group(8))
                    indels_2 = int(m.group(9))
                    read_tuple_id_w = int(m.group(10), 16)
                    pair = int(m.group(11))

                    chr_id = fai_index.dict_chr_ids[contig_name] if fai_index.dict_chr_ids != {} else "0"

                    if start_1 < end_2:
                        direction_1 = "F"
                        direction_2 = "R"
                    else:
                        direction_1 = "R"
                        direction_2 = "F"

                    segment1 = rnftools.rnfformat.Segment(
                        genome_id=genome_id,
                        chr_id=chr_id,
                        direction=direction_1,
                        left=start_1,
                        right=0,
                    )

                    segment2 = rnftools.rnfformat.Segment(
                        genome_id=genome_id,
                        chr_id=chr_id,
                        direction=direction_2,
                        left=0,
                        right=end_2,
                    )

                elif i % 4 == 1:
                    bases = lines[0]
                    if reads_in_tuple == 2:
                        bases2 = lines[1]

                elif i % 4 == 2:
                    pass

                elif i % 4 == 3:
                    qualities = lines[0]
                    if reads_in_tuple == 2:
                        qualities2 = lines[1]

                    if reads_in_tuple == 1:
                        fq_creator.add_read(
                            read_tuple_id=i // 4 + 1,
                            bases=bases,
                            qualities=qualities,
                            segments=[segment1, segment2],
                        )
                    else:
                        fq_creator.add_read(
                            read_tuple_id=i // 4 + 1,
                            bases=bases,
                            qualities=qualities,
                            segments=[segment1],
                        )
                        fq_creator.add_read(
                            read_tuple_id=i // 4 + 1,
                            bases=bases2,
                            qualities=qualities2,
                            segments=[segment2],
                        )

                i += 1

        fq_creator.flush_read_tuple()